file_id
stringlengths 5
9
| content
stringlengths 86
32.8k
| repo
stringlengths 9
63
| path
stringlengths 7
161
| token_length
int64 31
8.14k
| original_comment
stringlengths 5
4.92k
| comment_type
stringclasses 2
values | detected_lang
stringclasses 1
value | masked_comment
stringlengths 87
32.8k
| excluded
bool 2
classes |
|---|---|---|---|---|---|---|---|---|---|
18150_2 | package com.lag.lanlord.constant;
import com.lag.lanlord.LandlordBaseUtil;
import com.lag.lanlord.card.define.EnumCardTypePoker;
public interface Consts {
int ROLE_PEASANT = 1; // 农民
int ROLE_LANDLORD = 2; // 地主
int TYPE_HIGH = 1; // 单牌
int TYPE_PAIR = 2; // 一对
int TYPE_THREE = 3; // 三张
int TYPE_STRAIGHT = 4; // 顺子 例34567
int TYPE_SERIAL_PAIR = 5; // 连对 例778899
int TYPE_THREE_WITH_ONE = 6; // 三带1 例3335
int TYPE_THREE_WITH_TWO = 7; // 三带2 例88866
int TYPE_SERIAL_THREE = 8; // 三张的顺子 例777888
int TYPE_AIRPLANE = 9; // 飞机 多个连续的三带1或连续的三带2 例777888999456
int TYPE_FOUR_WITH_TWO = 10; // 四带二或四带两对
int TYPE_BOMB = 11; // 炸弹
int TYPE_ROCKET = 12; // 火箭(王炸)
// 部分牌值
int KING_MIN = EnumCardTypePoker.KING.getFirst();// 小王
int KING_MAX = EnumCardTypePoker.KING.getLast();// 大王
int SIGNBOARD = EnumCardTypePoker.SIGNBOARD.getFirst();// 广告牌
int KING_TYPE = LandlordBaseUtil.getCardType(KING_MIN); // 大小王的type
int KING_VALUE_MIN = LandlordBaseUtil.getCardValue(KING_MIN);// 小王解析后的value
int KING_VALUE_MAX = LandlordBaseUtil.getCardValue(KING_MAX);// 大王解析后的value
}
| Liuguozhu/landlord | src/com/lanlord/constant/Consts.java | 498 | // 三带1 例3335 | line_comment | zh-cn | package com.lag.lanlord.constant;
import com.lag.lanlord.LandlordBaseUtil;
import com.lag.lanlord.card.define.EnumCardTypePoker;
public interface Consts {
int ROLE_PEASANT = 1; // 农民
int ROLE_LANDLORD = 2; // 地主
int TYPE_HIGH = 1; // 单牌
int TYPE_PAIR = 2; // 一对
int TYPE_THREE = 3; // 三张
int TYPE_STRAIGHT = 4; // 顺子 例34567
int TYPE_SERIAL_PAIR = 5; // 连对 例778899
int TYPE_THREE_WITH_ONE = 6; // 三带 <SUF>
int TYPE_THREE_WITH_TWO = 7; // 三带2 例88866
int TYPE_SERIAL_THREE = 8; // 三张的顺子 例777888
int TYPE_AIRPLANE = 9; // 飞机 多个连续的三带1或连续的三带2 例777888999456
int TYPE_FOUR_WITH_TWO = 10; // 四带二或四带两对
int TYPE_BOMB = 11; // 炸弹
int TYPE_ROCKET = 12; // 火箭(王炸)
// 部分牌值
int KING_MIN = EnumCardTypePoker.KING.getFirst();// 小王
int KING_MAX = EnumCardTypePoker.KING.getLast();// 大王
int SIGNBOARD = EnumCardTypePoker.SIGNBOARD.getFirst();// 广告牌
int KING_TYPE = LandlordBaseUtil.getCardType(KING_MIN); // 大小王的type
int KING_VALUE_MIN = LandlordBaseUtil.getCardValue(KING_MIN);// 小王解析后的value
int KING_VALUE_MAX = LandlordBaseUtil.getCardValue(KING_MAX);// 大王解析后的value
}
| false |
34128_18 | package com.xuecheng.media;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;
import org.junit.jupiter.api.Test;
import org.springframework.http.MediaType;
import java.io.*;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 测试MinIO
*/
public class MinioTest {
static MinioClient minioClient =
MinioClient.builder()
.endpoint("http://43.137.8.13:9000")
.credentials("minioadmin", "minioadmin")
.build();
//上传文件
@Test
public void upload() throws Exception {
//根据扩展名取出mimeType
// ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(".mp4");
// String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;//通用mimeType，字节流
// if(extensionMatch!=null){
// mimeType = extensionMatch.getMimeType();
// }
UploadObjectArgs testbucket = UploadObjectArgs.builder()
.bucket("mediafiles")
.object("course/125.html")//添加子目录
.filename("E:\\java\\XueCheng\\upload\\125.html")
.build();
minioClient.uploadObject(testbucket);
System.out.println("上传成功");
}
//删除文件
@Test
public void delete() throws Exception {
RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket("xcbucket").object("1.jpg").build();
minioClient.removeObject(removeObjectArgs);
System.out.println("删除成功");
}
//下载文件
@Test
public void get() throws Exception {
GetObjectArgs getObjectArgs = GetObjectArgs.builder().bucket("xcbucket").object("1.jpg").build();
FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
FileOutputStream outputStream = new FileOutputStream(new File("F:\\360MoveData\\Users\\HUAWEI\\Desktop\\1.jpg"));
IOUtils.copy(inputStream,outputStream);
//校验文件的完整性对文件的内容进行md5
FileInputStream fileInputStream1 = new FileInputStream(new File("F:\\360MoveData\\Users\\HUAWEI\\Desktop\\新建文件夹\\1.jpg"));
String source_md5 = DigestUtils.md5Hex(fileInputStream1);
FileInputStream fileInputStream = new FileInputStream(new File("F:\\360MoveData\\Users\\HUAWEI\\Desktop\\1.jpg"));
String local_md5 = DigestUtils.md5Hex(fileInputStream);
if(source_md5.equals(local_md5)){
System.out.println("下载成功");
}
}
//上传分块文件
@Test
public void test_uploadChunk() throws Exception{
//分块文件路径
File chunkFolder=new File("E:\\java\\学成在线项目—资料\\upload\\");
//取出分块文件
File[] files = chunkFolder.listFiles();
for (int i = 0; i < files.length; i++) {
//上传文件
UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
.bucket("video") //桶
.object("ABC/"+i) //桶中文件名
.filename(files[i].getAbsolutePath()) //源文件
.build();
minioClient.uploadObject(uploadObjectArgs);
System.out.println("上传分块成功"+i);
}
}
//调用minio接口，合并分块文件
@Test
public void test_merge() throws Exception{
// List<ComposeSource> sources=new ArrayList<>();
// for (int i = 0; i < 25; i++) {
// ComposeSource composeSource = ComposeSource.builder().bucket("video").object("ABC/" + i).build();
// sources.add(composeSource);
// }
//需要合并的文件
List<ComposeSource> sources = Stream.iterate(0, i -> i++).limit(25).map(i -> ComposeSource.builder().bucket("video").object("ABC/" + i).build()).collect(Collectors.toList());
//合并参数
ComposeObjectArgs composeObjectArgs= ComposeObjectArgs.builder()
.bucket("video")
.object("ABC谋杀案.mkv")
.sources(sources) //需要合并的文件
.build();
minioClient.composeObject(composeObjectArgs);
}
/**
* 清楚分块文件
*/
@Test
public void clearChunkFiles() throws Exception{
String chunkFileFolderPath="b\\4\\b4e1dd897c4726e94f3b6f76f1822513\\chunk\\";
int chunkTotal=3;
List<DeleteObject> deleteObjects = Stream.iterate(0, i -> ++i)
.limit(chunkTotal)
.map(i -> new DeleteObject(chunkFileFolderPath.concat(Integer.toString(i))))
.collect(Collectors.toList());
Iterable<Result<DeleteError>> results = minioClient.removeObjects(
RemoveObjectsArgs.builder()
.bucket("video")
.objects(deleteObjects)
.build()
);
for (Result<DeleteError> result : results) {
DeleteError error = result.get();
}
}
}
| Liuhao801/xuecheng | xuecheng-plus-project/xuecheng-plus-media/xuecheng-plus-media-service/src/test/java/com/xuecheng/media/MinioTest.java | 1,355 | //调用minio接口，合并分块文件 | line_comment | zh-cn | package com.xuecheng.media;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;
import org.junit.jupiter.api.Test;
import org.springframework.http.MediaType;
import java.io.*;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 测试MinIO
*/
public class MinioTest {
static MinioClient minioClient =
MinioClient.builder()
.endpoint("http://43.137.8.13:9000")
.credentials("minioadmin", "minioadmin")
.build();
//上传文件
@Test
public void upload() throws Exception {
//根据扩展名取出mimeType
// ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(".mp4");
// String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;//通用mimeType，字节流
// if(extensionMatch!=null){
// mimeType = extensionMatch.getMimeType();
// }
UploadObjectArgs testbucket = UploadObjectArgs.builder()
.bucket("mediafiles")
.object("course/125.html")//添加子目录
.filename("E:\\java\\XueCheng\\upload\\125.html")
.build();
minioClient.uploadObject(testbucket);
System.out.println("上传成功");
}
//删除文件
@Test
public void delete() throws Exception {
RemoveObjectArgs removeObjectArgs = RemoveObjectArgs.builder().bucket("xcbucket").object("1.jpg").build();
minioClient.removeObject(removeObjectArgs);
System.out.println("删除成功");
}
//下载文件
@Test
public void get() throws Exception {
GetObjectArgs getObjectArgs = GetObjectArgs.builder().bucket("xcbucket").object("1.jpg").build();
FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
FileOutputStream outputStream = new FileOutputStream(new File("F:\\360MoveData\\Users\\HUAWEI\\Desktop\\1.jpg"));
IOUtils.copy(inputStream,outputStream);
//校验文件的完整性对文件的内容进行md5
FileInputStream fileInputStream1 = new FileInputStream(new File("F:\\360MoveData\\Users\\HUAWEI\\Desktop\\新建文件夹\\1.jpg"));
String source_md5 = DigestUtils.md5Hex(fileInputStream1);
FileInputStream fileInputStream = new FileInputStream(new File("F:\\360MoveData\\Users\\HUAWEI\\Desktop\\1.jpg"));
String local_md5 = DigestUtils.md5Hex(fileInputStream);
if(source_md5.equals(local_md5)){
System.out.println("下载成功");
}
}
//上传分块文件
@Test
public void test_uploadChunk() throws Exception{
//分块文件路径
File chunkFolder=new File("E:\\java\\学成在线项目—资料\\upload\\");
//取出分块文件
File[] files = chunkFolder.listFiles();
for (int i = 0; i < files.length; i++) {
//上传文件
UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
.bucket("video") //桶
.object("ABC/"+i) //桶中文件名
.filename(files[i].getAbsolutePath()) //源文件
.build();
minioClient.uploadObject(uploadObjectArgs);
System.out.println("上传分块成功"+i);
}
}
//调用 <SUF>
@Test
public void test_merge() throws Exception{
// List<ComposeSource> sources=new ArrayList<>();
// for (int i = 0; i < 25; i++) {
// ComposeSource composeSource = ComposeSource.builder().bucket("video").object("ABC/" + i).build();
// sources.add(composeSource);
// }
//需要合并的文件
List<ComposeSource> sources = Stream.iterate(0, i -> i++).limit(25).map(i -> ComposeSource.builder().bucket("video").object("ABC/" + i).build()).collect(Collectors.toList());
//合并参数
ComposeObjectArgs composeObjectArgs= ComposeObjectArgs.builder()
.bucket("video")
.object("ABC谋杀案.mkv")
.sources(sources) //需要合并的文件
.build();
minioClient.composeObject(composeObjectArgs);
}
/**
* 清楚分块文件
*/
@Test
public void clearChunkFiles() throws Exception{
String chunkFileFolderPath="b\\4\\b4e1dd897c4726e94f3b6f76f1822513\\chunk\\";
int chunkTotal=3;
List<DeleteObject> deleteObjects = Stream.iterate(0, i -> ++i)
.limit(chunkTotal)
.map(i -> new DeleteObject(chunkFileFolderPath.concat(Integer.toString(i))))
.collect(Collectors.toList());
Iterable<Result<DeleteError>> results = minioClient.removeObjects(
RemoveObjectsArgs.builder()
.bucket("video")
.objects(deleteObjects)
.build()
);
for (Result<DeleteError> result : results) {
DeleteError error = result.get();
}
}
}
| true |
22432_0 |
package Model;
/**
* 模块说明： 学生
*
*/
public class Student {
private int id;
private String sno;// 学号
private String name;
private String sex;
private String department;// 院系
private String homeTown;// 籍贯
private String mark;// 学分
private String email;
private String tel;// 联系方式
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public String getHomeTown() {
return homeTown;
}
public void setHomeTown(String homeTown) {
this.homeTown = homeTown;
}
public String getMark() {
return mark;
}
public void setMark(String mark) {
this.mark = mark;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
}
| Liujiang240556/StudentGradeMangerSystem | src/Model/Student.java | 450 | /**
* 模块说明： 学生
*
*/ | block_comment | zh-cn |
package Model;
/**
* 模块说 <SUF>*/
public class Student {
private int id;
private String sno;// 学号
private String name;
private String sex;
private String department;// 院系
private String homeTown;// 籍贯
private String mark;// 学分
private String email;
private String tel;// 联系方式
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSno() {
return sno;
}
public void setSno(String sno) {
this.sno = sno;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public String getHomeTown() {
return homeTown;
}
public void setHomeTown(String homeTown) {
this.homeTown = homeTown;
}
public String getMark() {
return mark;
}
public void setMark(String mark) {
this.mark = mark;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
}
| false |
42875_4 | /*
* @lc app=leetcode.cn id=260 lang=java
*
* [260] 只出现一次的数字 III
*/
// @lc code=start
class Solution {
public int[] singleNumber(int[] nums) {
// 所有数字异或之后相当于这两个数字它们的异或
// xorsum = x1 ^ x2
// 找到xorsum二进制里最右边的那个1所在的位置
// 明显,x1和x2在这个位置上必定一个是1一个是0
// 把所有数字根据在这个位置上是1还是0分为两类
// 那么part1就是一堆两次的数字跟x1的异或
// part2是另一堆两次的数字跟x2的异或
// 那么part1和part2就是最终答案
int xorsum = 0;
for (int num: nums) {
xorsum ^= num;
}
int lastIndexOfOne = xorsum == Integer.MIN_VALUE ? xorsum : xorsum & (-xorsum);
int part1 = 0;
int part2 = 0;
for (int num: nums) {
if ((num & lastIndexOfOne) != 0) {
part1 ^= num;
} else {
part2 ^= num;
}
}
return new int[]{part1, part2};
}
}
// @lc code=end
| LiuqingDu/leetcode | 260.只出现一次的数字-iii.java | 330 | // 找到xorsum二进制里最右边的那个1所在的位置 | line_comment | zh-cn | /*
* @lc app=leetcode.cn id=260 lang=java
*
* [260] 只出现一次的数字 III
*/
// @lc code=start
class Solution {
public int[] singleNumber(int[] nums) {
// 所有数字异或之后相当于这两个数字它们的异或
// xorsum = x1 ^ x2
// 找到 <SUF>
// 明显,x1和x2在这个位置上必定一个是1一个是0
// 把所有数字根据在这个位置上是1还是0分为两类
// 那么part1就是一堆两次的数字跟x1的异或
// part2是另一堆两次的数字跟x2的异或
// 那么part1和part2就是最终答案
int xorsum = 0;
for (int num: nums) {
xorsum ^= num;
}
int lastIndexOfOne = xorsum == Integer.MIN_VALUE ? xorsum : xorsum & (-xorsum);
int part1 = 0;
int part2 = 0;
for (int num: nums) {
if ((num & lastIndexOfOne) != 0) {
part1 ^= num;
} else {
part2 ^= num;
}
}
return new int[]{part1, part2};
}
}
// @lc code=end
| true |
20561_5 | public class Q441 {
/**
* brute force， 会TLE
*/
public static int arrangeCoins1(int n) {
// find the level
int sum = 0;
int res = 0;
int curLevel = 1;
while (sum + curLevel <= n) {
sum += curLevel;
curLevel += 1;
res++;
}
System.out.println("sum" + sum);
System.out.println("curLevel" + curLevel);
// 这样出循环后就是除了素后一行的sum了
return res;
}
/**
* 二分
* 可以取的行数在[1, n]之间
*
*/
public int arrangeCoins(int n) {
long L = 0, R = n;
while (L <= R) {
long M = L + (R - L) / 2;
// 利用等差数列公式，求出前N行的和
long cur = M * (M + 1) / 2;
// 当前这行小于N,且下一行加上就大于N了，那这就是答案
if (cur <= n && cur + M + 1 > n) {
return (int)M;
}
if (cur > n) {
R = M - 1;
} else {
L = M + 1;
}
}
return 1;
}
public static void main(String[] args) {
arrangeCoins(8);
}
}
| Livia328/Livia_Leetcode | Java/Q441.java | 350 | // 当前这行小于N,且下一行加上就大于N了，那这就是答案 | line_comment | zh-cn | public class Q441 {
/**
* brute force， 会TLE
*/
public static int arrangeCoins1(int n) {
// find the level
int sum = 0;
int res = 0;
int curLevel = 1;
while (sum + curLevel <= n) {
sum += curLevel;
curLevel += 1;
res++;
}
System.out.println("sum" + sum);
System.out.println("curLevel" + curLevel);
// 这样出循环后就是除了素后一行的sum了
return res;
}
/**
* 二分
* 可以取的行数在[1, n]之间
*
*/
public int arrangeCoins(int n) {
long L = 0, R = n;
while (L <= R) {
long M = L + (R - L) / 2;
// 利用等差数列公式，求出前N行的和
long cur = M * (M + 1) / 2;
// 当前 <SUF>
if (cur <= n && cur + M + 1 > n) {
return (int)M;
}
if (cur > n) {
R = M - 1;
} else {
L = M + 1;
}
}
return 1;
}
public static void main(String[] args) {
arrangeCoins(8);
}
}
| true |
48597_95 | package com.alipay.demo.trade;
import com.alipay.api.AlipayResponse;
import com.alipay.api.domain.TradeFundBill;
import com.alipay.api.response.AlipayTradePrecreateResponse;
import com.alipay.api.response.AlipayTradeQueryResponse;
import com.alipay.api.response.MonitorHeartbeatSynResponse;
import com.alipay.demo.trade.config.Configs;
import com.alipay.demo.trade.model.ExtendParams;
import com.alipay.demo.trade.model.GoodsDetail;
import com.alipay.demo.trade.model.builder.*;
import com.alipay.demo.trade.model.hb.*;
import com.alipay.demo.trade.model.result.AlipayF2FPayResult;
import com.alipay.demo.trade.model.result.AlipayF2FPrecreateResult;
import com.alipay.demo.trade.model.result.AlipayF2FQueryResult;
import com.alipay.demo.trade.model.result.AlipayF2FRefundResult;
import com.alipay.demo.trade.service.AlipayMonitorService;
import com.alipay.demo.trade.service.AlipayTradeService;
import com.alipay.demo.trade.service.impl.AlipayMonitorServiceImpl;
import com.alipay.demo.trade.service.impl.AlipayTradeServiceImpl;
import com.alipay.demo.trade.service.impl.AlipayTradeWithHBServiceImpl;
import com.alipay.demo.trade.utils.Utils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by liuyangkly on 15/8/9.
* 简单main函数，用于测试当面付api
* sdk和demo的意见和问题反馈请联系：liuyang.kly@alipay.com
*/
public class Main {
private static Log log = LogFactory.getLog(Main.class);
// 支付宝当面付2.0服务
private static AlipayTradeService tradeService;
// 支付宝当面付2.0服务（集成了交易保障接口逻辑）
private static AlipayTradeService tradeWithHBService;
// 支付宝交易保障接口服务，供测试接口api使用，请先阅读readme.txt
private static AlipayMonitorService monitorService;
static {
/** 一定要在创建AlipayTradeService之前调用Configs.init()设置默认参数
* Configs会读取classpath下的zfbinfo.properties文件配置信息，如果找不到该文件则确认该文件是否在classpath目录
*/
Configs.init("zfbinfo.properties");
/** 使用Configs提供的默认参数
* AlipayTradeService可以使用单例或者为静态成员对象，不需要反复new
*/
tradeService = new AlipayTradeServiceImpl.ClientBuilder().build();
// 支付宝当面付2.0服务（集成了交易保障接口逻辑）
tradeWithHBService = new AlipayTradeWithHBServiceImpl.ClientBuilder().build();
/** 如果需要在程序中覆盖Configs提供的默认参数, 可以使用ClientBuilder类的setXXX方法修改默认参数 否则使用代码中的默认设置 */
monitorService = new AlipayMonitorServiceImpl.ClientBuilder()
.setGatewayUrl("http://mcloudmonitor.com/gateway.do").setCharset("GBK")
.setFormat("json").build();
}
// 简单打印应答
private void dumpResponse(AlipayResponse response) {
if (response != null) {
log.info(String.format("code:%s, msg:%s", response.getCode(), response.getMsg()));
if (StringUtils.isNotEmpty(response.getSubCode())) {
log.info(String.format("subCode:%s, subMsg:%s", response.getSubCode(),
response.getSubMsg()));
}
log.info("body:" + response.getBody());
}
}
public static void main(String[] args) {
Main main = new Main();
// 系统商商测试交易保障接口api
// main.test_monitor_sys();
// POS厂商测试交易保障接口api
// main.test_monitor_pos();
// 测试交易保障接口调度
// main.test_monitor_schedule_logic();
// 测试当面付2.0支付（使用未集成交易保障接口的当面付2.0服务）
// main.test_trade_pay(tradeService);
// 测试查询当面付2.0交易
// main.test_trade_query();
// 测试当面付2.0退货
// main.test_trade_refund();
// 测试当面付2.0生成支付二维码
main.test_trade_precreate();
}
// 测试系统商交易保障调度
public void test_monitor_schedule_logic() {
// 启动交易保障线程
DemoHbRunner demoRunner = new DemoHbRunner(monitorService);
demoRunner.setDelay(5); // 设置启动后延迟5秒开始调度，不设置则默认3秒
demoRunner.setDuration(10); // 设置间隔10秒进行调度，不设置则默认15 * 60秒
demoRunner.schedule();
// 启动当面付，此处每隔5秒调用一次支付接口，并且当随机数为0时交易保障线程退出
while (Math.random() != 0) {
test_trade_pay(tradeWithHBService);
Utils.sleep(5 * 1000);
}
// 满足退出条件后可以调用shutdown优雅安全退出
demoRunner.shutdown();
}
// 系统商的调用样例，填写了所有系统商商需要填写的字段
public void test_monitor_sys() {
// 系统商使用的交易信息格式，json字符串类型
List<SysTradeInfo> sysTradeInfoList = new ArrayList<SysTradeInfo>();
sysTradeInfoList.add(SysTradeInfo.newInstance("00000001", 5.2, HbStatus.S));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000002", 4.4, HbStatus.F));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000003", 11.3, HbStatus.P));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000004", 3.2, HbStatus.X));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000005", 4.1, HbStatus.X));
// 填写异常信息，如果有的话
List<ExceptionInfo> exceptionInfoList = new ArrayList<ExceptionInfo>();
exceptionInfoList.add(ExceptionInfo.HE_SCANER);
// exceptionInfoList.add(ExceptionInfo.HE_PRINTER);
// exceptionInfoList.add(ExceptionInfo.HE_OTHER);
// 填写扩展参数，如果有的话
Map<String, Object> extendInfo = new HashMap<String, Object>();
// extendInfo.put("SHOP_ID", "BJ_ZZ_001");
// extendInfo.put("TERMINAL_ID", "1234");
String appAuthToken = "应用授权令牌";//根据真实值填写
AlipayHeartbeatSynRequestBuilder builder = new AlipayHeartbeatSynRequestBuilder()
.setAppAuthToken(appAuthToken).setProduct(Product.FP).setType(Type.CR)
.setEquipmentId("cr1000001").setEquipmentStatus(EquipStatus.NORMAL)
.setTime(Utils.toDate(new Date())).setStoreId("store10001").setMac("0a:00:27:00:00:00")
.setNetworkType("LAN").setProviderId("2088911212323549") // 设置系统商pid
.setSysTradeInfoList(sysTradeInfoList) // 系统商同步trade_info信息
// .setExceptionInfoList(exceptionInfoList) // 填写异常信息，如果有的话
.setExtendInfo(extendInfo) // 填写扩展信息，如果有的话
;
MonitorHeartbeatSynResponse response = monitorService.heartbeatSyn(builder);
dumpResponse(response);
}
// POS厂商的调用样例，填写了所有pos厂商需要填写的字段
public void test_monitor_pos() {
// POS厂商使用的交易信息格式，字符串类型
List<PosTradeInfo> posTradeInfoList = new ArrayList<PosTradeInfo>();
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.S, "1324", 7));
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.X, "1326", 15));
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.S, "1401", 8));
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.F, "1405", 3));
// 填写异常信息，如果有的话
List<ExceptionInfo> exceptionInfoList = new ArrayList<ExceptionInfo>();
exceptionInfoList.add(ExceptionInfo.HE_PRINTER);
// 填写扩展参数，如果有的话
Map<String, Object> extendInfo = new HashMap<String, Object>();
// extendInfo.put("SHOP_ID", "BJ_ZZ_001");
// extendInfo.put("TERMINAL_ID", "1234");
AlipayHeartbeatSynRequestBuilder builder = new AlipayHeartbeatSynRequestBuilder()
.setProduct(Product.FP)
.setType(Type.SOFT_POS)
.setEquipmentId("soft100001")
.setEquipmentStatus(EquipStatus.NORMAL)
.setTime("2015-09-28 11:14:49")
.setManufacturerPid("2088000000000009")
// 填写机具商的支付宝pid
.setStoreId("store200001").setEquipmentPosition("31.2433190000,121.5090750000")
.setBbsPosition("2869719733-065|2896507033-091").setNetworkStatus("gggbbbgggnnn")
.setNetworkType("3G").setBattery("98").setWifiMac("0a:00:27:00:00:00")
.setWifiName("test_wifi_name").setIp("192.168.1.188")
.setPosTradeInfoList(posTradeInfoList) // POS厂商同步trade_info信息
// .setExceptionInfoList(exceptionInfoList) // 填写异常信息，如果有的话
.setExtendInfo(extendInfo) // 填写扩展信息，如果有的话
;
MonitorHeartbeatSynResponse response = monitorService.heartbeatSyn(builder);
dumpResponse(response);
}
// 测试当面付2.0支付
public void test_trade_pay(AlipayTradeService service) {
// (必填) 商户网站订单系统中唯一订单号，64个字符以内，只能包含字母、数字、下划线，
// 需保证商户系统端不能重复，建议通过数据库sequence生成，
String outTradeNo = "tradepay" + System.currentTimeMillis()
+ (long) (Math.random() * 10000000L);
// (必填) 订单标题，粗略描述用户的支付目的。如“xxx品牌xxx门店消费”
String subject = "xxx品牌xxx门店当面付消费";
// (必填) 订单总金额，单位为元，不能超过1亿元
// 如果同时传入了【打折金额】,【不可打折金额】,【订单总金额】三者,则必须满足如下条件:【订单总金额】=【打折金额】+【不可打折金额】
String totalAmount = "0.01";
// (必填) 付款条码，用户支付宝钱包手机app点击“付款”产生的付款条码
String authCode = "用户自己的支付宝付款码"; // 条码示例，286648048691290423
// (可选，根据需要决定是否使用) 订单可打折金额，可以配合商家平台配置折扣活动，如果订单部分商品参与打折，可以将部分商品总价填写至此字段，默认全部商品可打折
// 如果该值未传入,但传入了【订单总金额】,【不可打折金额】 则该值默认为【订单总金额】- 【不可打折金额】
// String discountableAmount = "1.00"; //
// (可选) 订单不可打折金额，可以配合商家平台配置折扣活动，如果酒水不参与打折，则将对应金额填写至此字段
// 如果该值未传入,但传入了【订单总金额】,【打折金额】,则该值默认为【订单总金额】-【打折金额】
String undiscountableAmount = "0.0";
// 卖家支付宝账号ID，用于支持一个签约账号下支持打款到不同的收款账号，(打款到sellerId对应的支付宝账号)
// 如果该字段为空，则默认为与支付宝签约的商户的PID，也就是appid对应的PID
String sellerId = "";
// 订单描述，可以对交易或商品进行一个详细地描述，比如填写"购买商品3件共20.00元"
String body = "购买商品3件共20.00元";
// 商户操作员编号，添加此参数可以为商户操作员做销售统计
String operatorId = "test_operator_id";
// (必填) 商户门店编号，通过门店号和商家后台可以配置精准到门店的折扣信息，详询支付宝技术支持
String storeId = "test_store_id";
// 业务扩展参数，目前可添加由支付宝分配的系统商编号(通过setSysServiceProviderId方法)，详情请咨询支付宝技术支持
String providerId = "2088100200300400500";
ExtendParams extendParams = new ExtendParams();
extendParams.setSysServiceProviderId(providerId);
// 支付超时，线下扫码交易定义为5分钟
String timeoutExpress = "5m";
// 商品明细列表，需填写购买商品详细信息，
List<GoodsDetail> goodsDetailList = new ArrayList<GoodsDetail>();
// 创建一个商品信息，参数含义分别为商品id（使用国标）、名称、单价（单位为分）、数量，如果需要添加商品类别，详见GoodsDetail
GoodsDetail goods1 = GoodsDetail.newInstance("goods_id001", "xxx面包", 1000, 1);
// 创建好一个商品后添加至商品明细列表
goodsDetailList.add(goods1);
// 继续创建并添加第一条商品信息，用户购买的产品为“黑人牙刷”，单价为5.00元，购买了两件
GoodsDetail goods2 = GoodsDetail.newInstance("goods_id002", "xxx牙刷", 500, 2);
goodsDetailList.add(goods2);
String appAuthToken = "应用授权令牌";//根据真实值填写
// 创建条码支付请求builder，设置请求参数
AlipayTradePayRequestBuilder builder = new AlipayTradePayRequestBuilder()
// .setAppAuthToken(appAuthToken)
.setOutTradeNo(outTradeNo).setSubject(subject).setAuthCode(authCode)
.setTotalAmount(totalAmount).setStoreId(storeId)
.setUndiscountableAmount(undiscountableAmount).setBody(body).setOperatorId(operatorId)
.setExtendParams(extendParams).setSellerId(sellerId)
.setGoodsDetailList(goodsDetailList).setTimeoutExpress(timeoutExpress);
// 调用tradePay方法获取当面付应答
AlipayF2FPayResult result = service.tradePay(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("支付宝支付成功: )");
break;
case FAILED:
log.error("支付宝支付失败!!!");
break;
case UNKNOWN:
log.error("系统异常，订单状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
// 测试当面付2.0查询订单
public void test_trade_query() {
// (必填) 商户订单号，通过此商户订单号查询当面付的交易状态
String outTradeNo = "tradepay14817938139942440181";
// 创建查询请求builder，设置请求参数
AlipayTradeQueryRequestBuilder builder = new AlipayTradeQueryRequestBuilder()
.setOutTradeNo(outTradeNo);
AlipayF2FQueryResult result = tradeService.queryTradeResult(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("查询返回该订单支付成功: )");
AlipayTradeQueryResponse response = result.getResponse();
dumpResponse(response);
log.info(response.getTradeStatus());
if (Utils.isListNotEmpty(response.getFundBillList())) {
for (TradeFundBill bill : response.getFundBillList()) {
log.info(bill.getFundChannel() + ":" + bill.getAmount());
}
}
break;
case FAILED:
log.error("查询返回该订单支付失败或被关闭!!!");
break;
case UNKNOWN:
log.error("系统异常，订单支付状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
// 测试当面付2.0退款
public void test_trade_refund() {
// (必填) 外部订单号，需要退款交易的商户外部订单号
String outTradeNo = "tradepay14817938139942440181";
// (必填) 退款金额，该金额必须小于等于订单的支付金额，单位为元
String refundAmount = "0.01";
// (可选，需要支持重复退货时必填) 商户退款请求号，相同支付宝交易号下的不同退款请求号对应同一笔交易的不同退款申请，
// 对于相同支付宝交易号下多笔相同商户退款请求号的退款交易，支付宝只会进行一次退款
String outRequestNo = "";
// (必填) 退款原因，可以说明用户退款原因，方便为商家后台提供统计
String refundReason = "正常退款，用户买多了";
// (必填) 商户门店编号，退款情况下可以为商家后台提供退款权限判定和统计等作用，详询支付宝技术支持
String storeId = "test_store_id";
// 创建退款请求builder，设置请求参数
AlipayTradeRefundRequestBuilder builder = new AlipayTradeRefundRequestBuilder()
.setOutTradeNo(outTradeNo).setRefundAmount(refundAmount).setRefundReason(refundReason)
.setOutRequestNo(outRequestNo).setStoreId(storeId);
AlipayF2FRefundResult result = tradeService.tradeRefund(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("支付宝退款成功: )");
break;
case FAILED:
log.error("支付宝退款失败!!!");
break;
case UNKNOWN:
log.error("系统异常，订单退款状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
// 测试当面付2.0生成支付二维码
public void test_trade_precreate() {
// (必填) 商户网站订单系统中唯一订单号，64个字符以内，只能包含字母、数字、下划线，
// 需保证商户系统端不能重复，建议通过数据库sequence生成，
String outTradeNo = "tradeprecreate" + System.currentTimeMillis()
+ (long) (Math.random() * 10000000L);
// (必填) 订单标题，粗略描述用户的支付目的。如“xxx品牌xxx门店当面付扫码消费”
String subject = "xxx品牌xxx门店当面付扫码消费";
// (必填) 订单总金额，单位为元，不能超过1亿元
// 如果同时传入了【打折金额】,【不可打折金额】,【订单总金额】三者,则必须满足如下条件:【订单总金额】=【打折金额】+【不可打折金额】
String totalAmount = "0.01";
// (可选) 订单不可打折金额，可以配合商家平台配置折扣活动，如果酒水不参与打折，则将对应金额填写至此字段
// 如果该值未传入,但传入了【订单总金额】,【打折金额】,则该值默认为【订单总金额】-【打折金额】
String undiscountableAmount = "0";
// 卖家支付宝账号ID，用于支持一个签约账号下支持打款到不同的收款账号，(打款到sellerId对应的支付宝账号)
// 如果该字段为空，则默认为与支付宝签约的商户的PID，也就是appid对应的PID
String sellerId = "";
// 订单描述，可以对交易或商品进行一个详细地描述，比如填写"购买商品2件共15.00元"
String body = "购买商品3件共20.00元";
// 商户操作员编号，添加此参数可以为商户操作员做销售统计
String operatorId = "test_operator_id";
// (必填) 商户门店编号，通过门店号和商家后台可以配置精准到门店的折扣信息，详询支付宝技术支持
String storeId = "test_store_id";
// 业务扩展参数，目前可添加由支付宝分配的系统商编号(通过setSysServiceProviderId方法)，详情请咨询支付宝技术支持
ExtendParams extendParams = new ExtendParams();
extendParams.setSysServiceProviderId("2088100200300400500");
// 支付超时，定义为120分钟
String timeoutExpress = "120m";
// 商品明细列表，需填写购买商品详细信息，
List<GoodsDetail> goodsDetailList = new ArrayList<GoodsDetail>();
// 创建一个商品信息，参数含义分别为商品id（使用国标）、名称、单价（单位为分）、数量，如果需要添加商品类别，详见GoodsDetail
GoodsDetail goods1 = GoodsDetail.newInstance("goods_id001", "xxx小面包", 1000, 1);
// 创建好一个商品后添加至商品明细列表
goodsDetailList.add(goods1);
// 继续创建并添加第一条商品信息，用户购买的产品为“黑人牙刷”，单价为5.00元，购买了两件
GoodsDetail goods2 = GoodsDetail.newInstance("goods_id002", "xxx牙刷", 500, 2);
goodsDetailList.add(goods2);
// 创建扫码支付请求builder，设置请求参数
AlipayTradePrecreateRequestBuilder builder = new AlipayTradePrecreateRequestBuilder()
.setSubject(subject).setTotalAmount(totalAmount).setOutTradeNo(outTradeNo)
.setUndiscountableAmount(undiscountableAmount).setSellerId(sellerId).setBody(body)
.setOperatorId(operatorId).setStoreId(storeId).setExtendParams(extendParams)
.setTimeoutExpress(timeoutExpress)
// .setNotifyUrl("http://www.test-notify-url.com")//支付宝服务器主动通知商户服务器里指定的页面http路径,根据需要设置
.setGoodsDetailList(goodsDetailList);
AlipayF2FPrecreateResult result = tradeService.tradePrecreate(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("支付宝预下单成功: )");
AlipayTradePrecreateResponse response = result.getResponse();
dumpResponse(response);
// 需要修改为运行机器上的路径
String filePath = String.format("/Users/sudo/Desktop/qr-%s.png",
response.getOutTradeNo());
log.info("filePath:" + filePath);
// ZxingUtils.getQRCodeImge(response.getQrCode(), 256, filePath);
break;
case FAILED:
log.error("支付宝预下单失败!!!");
break;
case UNKNOWN:
log.error("系统异常，预下单状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
}
| Liweimin0512/MMall_JAVA | server/src/main/java/com/alipay/demo/trade/Main.java | 6,027 | // (必填) 订单总金额，单位为元，不能超过1亿元 | line_comment | zh-cn | package com.alipay.demo.trade;
import com.alipay.api.AlipayResponse;
import com.alipay.api.domain.TradeFundBill;
import com.alipay.api.response.AlipayTradePrecreateResponse;
import com.alipay.api.response.AlipayTradeQueryResponse;
import com.alipay.api.response.MonitorHeartbeatSynResponse;
import com.alipay.demo.trade.config.Configs;
import com.alipay.demo.trade.model.ExtendParams;
import com.alipay.demo.trade.model.GoodsDetail;
import com.alipay.demo.trade.model.builder.*;
import com.alipay.demo.trade.model.hb.*;
import com.alipay.demo.trade.model.result.AlipayF2FPayResult;
import com.alipay.demo.trade.model.result.AlipayF2FPrecreateResult;
import com.alipay.demo.trade.model.result.AlipayF2FQueryResult;
import com.alipay.demo.trade.model.result.AlipayF2FRefundResult;
import com.alipay.demo.trade.service.AlipayMonitorService;
import com.alipay.demo.trade.service.AlipayTradeService;
import com.alipay.demo.trade.service.impl.AlipayMonitorServiceImpl;
import com.alipay.demo.trade.service.impl.AlipayTradeServiceImpl;
import com.alipay.demo.trade.service.impl.AlipayTradeWithHBServiceImpl;
import com.alipay.demo.trade.utils.Utils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by liuyangkly on 15/8/9.
* 简单main函数，用于测试当面付api
* sdk和demo的意见和问题反馈请联系：liuyang.kly@alipay.com
*/
public class Main {
private static Log log = LogFactory.getLog(Main.class);
// 支付宝当面付2.0服务
private static AlipayTradeService tradeService;
// 支付宝当面付2.0服务（集成了交易保障接口逻辑）
private static AlipayTradeService tradeWithHBService;
// 支付宝交易保障接口服务，供测试接口api使用，请先阅读readme.txt
private static AlipayMonitorService monitorService;
static {
/** 一定要在创建AlipayTradeService之前调用Configs.init()设置默认参数
* Configs会读取classpath下的zfbinfo.properties文件配置信息，如果找不到该文件则确认该文件是否在classpath目录
*/
Configs.init("zfbinfo.properties");
/** 使用Configs提供的默认参数
* AlipayTradeService可以使用单例或者为静态成员对象，不需要反复new
*/
tradeService = new AlipayTradeServiceImpl.ClientBuilder().build();
// 支付宝当面付2.0服务（集成了交易保障接口逻辑）
tradeWithHBService = new AlipayTradeWithHBServiceImpl.ClientBuilder().build();
/** 如果需要在程序中覆盖Configs提供的默认参数, 可以使用ClientBuilder类的setXXX方法修改默认参数 否则使用代码中的默认设置 */
monitorService = new AlipayMonitorServiceImpl.ClientBuilder()
.setGatewayUrl("http://mcloudmonitor.com/gateway.do").setCharset("GBK")
.setFormat("json").build();
}
// 简单打印应答
private void dumpResponse(AlipayResponse response) {
if (response != null) {
log.info(String.format("code:%s, msg:%s", response.getCode(), response.getMsg()));
if (StringUtils.isNotEmpty(response.getSubCode())) {
log.info(String.format("subCode:%s, subMsg:%s", response.getSubCode(),
response.getSubMsg()));
}
log.info("body:" + response.getBody());
}
}
public static void main(String[] args) {
Main main = new Main();
// 系统商商测试交易保障接口api
// main.test_monitor_sys();
// POS厂商测试交易保障接口api
// main.test_monitor_pos();
// 测试交易保障接口调度
// main.test_monitor_schedule_logic();
// 测试当面付2.0支付（使用未集成交易保障接口的当面付2.0服务）
// main.test_trade_pay(tradeService);
// 测试查询当面付2.0交易
// main.test_trade_query();
// 测试当面付2.0退货
// main.test_trade_refund();
// 测试当面付2.0生成支付二维码
main.test_trade_precreate();
}
// 测试系统商交易保障调度
public void test_monitor_schedule_logic() {
// 启动交易保障线程
DemoHbRunner demoRunner = new DemoHbRunner(monitorService);
demoRunner.setDelay(5); // 设置启动后延迟5秒开始调度，不设置则默认3秒
demoRunner.setDuration(10); // 设置间隔10秒进行调度，不设置则默认15 * 60秒
demoRunner.schedule();
// 启动当面付，此处每隔5秒调用一次支付接口，并且当随机数为0时交易保障线程退出
while (Math.random() != 0) {
test_trade_pay(tradeWithHBService);
Utils.sleep(5 * 1000);
}
// 满足退出条件后可以调用shutdown优雅安全退出
demoRunner.shutdown();
}
// 系统商的调用样例，填写了所有系统商商需要填写的字段
public void test_monitor_sys() {
// 系统商使用的交易信息格式，json字符串类型
List<SysTradeInfo> sysTradeInfoList = new ArrayList<SysTradeInfo>();
sysTradeInfoList.add(SysTradeInfo.newInstance("00000001", 5.2, HbStatus.S));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000002", 4.4, HbStatus.F));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000003", 11.3, HbStatus.P));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000004", 3.2, HbStatus.X));
sysTradeInfoList.add(SysTradeInfo.newInstance("00000005", 4.1, HbStatus.X));
// 填写异常信息，如果有的话
List<ExceptionInfo> exceptionInfoList = new ArrayList<ExceptionInfo>();
exceptionInfoList.add(ExceptionInfo.HE_SCANER);
// exceptionInfoList.add(ExceptionInfo.HE_PRINTER);
// exceptionInfoList.add(ExceptionInfo.HE_OTHER);
// 填写扩展参数，如果有的话
Map<String, Object> extendInfo = new HashMap<String, Object>();
// extendInfo.put("SHOP_ID", "BJ_ZZ_001");
// extendInfo.put("TERMINAL_ID", "1234");
String appAuthToken = "应用授权令牌";//根据真实值填写
AlipayHeartbeatSynRequestBuilder builder = new AlipayHeartbeatSynRequestBuilder()
.setAppAuthToken(appAuthToken).setProduct(Product.FP).setType(Type.CR)
.setEquipmentId("cr1000001").setEquipmentStatus(EquipStatus.NORMAL)
.setTime(Utils.toDate(new Date())).setStoreId("store10001").setMac("0a:00:27:00:00:00")
.setNetworkType("LAN").setProviderId("2088911212323549") // 设置系统商pid
.setSysTradeInfoList(sysTradeInfoList) // 系统商同步trade_info信息
// .setExceptionInfoList(exceptionInfoList) // 填写异常信息，如果有的话
.setExtendInfo(extendInfo) // 填写扩展信息，如果有的话
;
MonitorHeartbeatSynResponse response = monitorService.heartbeatSyn(builder);
dumpResponse(response);
}
// POS厂商的调用样例，填写了所有pos厂商需要填写的字段
public void test_monitor_pos() {
// POS厂商使用的交易信息格式，字符串类型
List<PosTradeInfo> posTradeInfoList = new ArrayList<PosTradeInfo>();
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.S, "1324", 7));
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.X, "1326", 15));
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.S, "1401", 8));
posTradeInfoList.add(PosTradeInfo.newInstance(HbStatus.F, "1405", 3));
// 填写异常信息，如果有的话
List<ExceptionInfo> exceptionInfoList = new ArrayList<ExceptionInfo>();
exceptionInfoList.add(ExceptionInfo.HE_PRINTER);
// 填写扩展参数，如果有的话
Map<String, Object> extendInfo = new HashMap<String, Object>();
// extendInfo.put("SHOP_ID", "BJ_ZZ_001");
// extendInfo.put("TERMINAL_ID", "1234");
AlipayHeartbeatSynRequestBuilder builder = new AlipayHeartbeatSynRequestBuilder()
.setProduct(Product.FP)
.setType(Type.SOFT_POS)
.setEquipmentId("soft100001")
.setEquipmentStatus(EquipStatus.NORMAL)
.setTime("2015-09-28 11:14:49")
.setManufacturerPid("2088000000000009")
// 填写机具商的支付宝pid
.setStoreId("store200001").setEquipmentPosition("31.2433190000,121.5090750000")
.setBbsPosition("2869719733-065|2896507033-091").setNetworkStatus("gggbbbgggnnn")
.setNetworkType("3G").setBattery("98").setWifiMac("0a:00:27:00:00:00")
.setWifiName("test_wifi_name").setIp("192.168.1.188")
.setPosTradeInfoList(posTradeInfoList) // POS厂商同步trade_info信息
// .setExceptionInfoList(exceptionInfoList) // 填写异常信息，如果有的话
.setExtendInfo(extendInfo) // 填写扩展信息，如果有的话
;
MonitorHeartbeatSynResponse response = monitorService.heartbeatSyn(builder);
dumpResponse(response);
}
// 测试当面付2.0支付
public void test_trade_pay(AlipayTradeService service) {
// (必填) 商户网站订单系统中唯一订单号，64个字符以内，只能包含字母、数字、下划线，
// 需保证商户系统端不能重复，建议通过数据库sequence生成，
String outTradeNo = "tradepay" + System.currentTimeMillis()
+ (long) (Math.random() * 10000000L);
// (必填) 订单标题，粗略描述用户的支付目的。如“xxx品牌xxx门店消费”
String subject = "xxx品牌xxx门店当面付消费";
// (必填) 订单总金额，单位为元，不能超过1亿元
// 如果同时传入了【打折金额】,【不可打折金额】,【订单总金额】三者,则必须满足如下条件:【订单总金额】=【打折金额】+【不可打折金额】
String totalAmount = "0.01";
// (必填) 付款条码，用户支付宝钱包手机app点击“付款”产生的付款条码
String authCode = "用户自己的支付宝付款码"; // 条码示例，286648048691290423
// (可选，根据需要决定是否使用) 订单可打折金额，可以配合商家平台配置折扣活动，如果订单部分商品参与打折，可以将部分商品总价填写至此字段，默认全部商品可打折
// 如果该值未传入,但传入了【订单总金额】,【不可打折金额】 则该值默认为【订单总金额】- 【不可打折金额】
// String discountableAmount = "1.00"; //
// (可选) 订单不可打折金额，可以配合商家平台配置折扣活动，如果酒水不参与打折，则将对应金额填写至此字段
// 如果该值未传入,但传入了【订单总金额】,【打折金额】,则该值默认为【订单总金额】-【打折金额】
String undiscountableAmount = "0.0";
// 卖家支付宝账号ID，用于支持一个签约账号下支持打款到不同的收款账号，(打款到sellerId对应的支付宝账号)
// 如果该字段为空，则默认为与支付宝签约的商户的PID，也就是appid对应的PID
String sellerId = "";
// 订单描述，可以对交易或商品进行一个详细地描述，比如填写"购买商品3件共20.00元"
String body = "购买商品3件共20.00元";
// 商户操作员编号，添加此参数可以为商户操作员做销售统计
String operatorId = "test_operator_id";
// (必填) 商户门店编号，通过门店号和商家后台可以配置精准到门店的折扣信息，详询支付宝技术支持
String storeId = "test_store_id";
// 业务扩展参数，目前可添加由支付宝分配的系统商编号(通过setSysServiceProviderId方法)，详情请咨询支付宝技术支持
String providerId = "2088100200300400500";
ExtendParams extendParams = new ExtendParams();
extendParams.setSysServiceProviderId(providerId);
// 支付超时，线下扫码交易定义为5分钟
String timeoutExpress = "5m";
// 商品明细列表，需填写购买商品详细信息，
List<GoodsDetail> goodsDetailList = new ArrayList<GoodsDetail>();
// 创建一个商品信息，参数含义分别为商品id（使用国标）、名称、单价（单位为分）、数量，如果需要添加商品类别，详见GoodsDetail
GoodsDetail goods1 = GoodsDetail.newInstance("goods_id001", "xxx面包", 1000, 1);
// 创建好一个商品后添加至商品明细列表
goodsDetailList.add(goods1);
// 继续创建并添加第一条商品信息，用户购买的产品为“黑人牙刷”，单价为5.00元，购买了两件
GoodsDetail goods2 = GoodsDetail.newInstance("goods_id002", "xxx牙刷", 500, 2);
goodsDetailList.add(goods2);
String appAuthToken = "应用授权令牌";//根据真实值填写
// 创建条码支付请求builder，设置请求参数
AlipayTradePayRequestBuilder builder = new AlipayTradePayRequestBuilder()
// .setAppAuthToken(appAuthToken)
.setOutTradeNo(outTradeNo).setSubject(subject).setAuthCode(authCode)
.setTotalAmount(totalAmount).setStoreId(storeId)
.setUndiscountableAmount(undiscountableAmount).setBody(body).setOperatorId(operatorId)
.setExtendParams(extendParams).setSellerId(sellerId)
.setGoodsDetailList(goodsDetailList).setTimeoutExpress(timeoutExpress);
// 调用tradePay方法获取当面付应答
AlipayF2FPayResult result = service.tradePay(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("支付宝支付成功: )");
break;
case FAILED:
log.error("支付宝支付失败!!!");
break;
case UNKNOWN:
log.error("系统异常，订单状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
// 测试当面付2.0查询订单
public void test_trade_query() {
// (必填) 商户订单号，通过此商户订单号查询当面付的交易状态
String outTradeNo = "tradepay14817938139942440181";
// 创建查询请求builder，设置请求参数
AlipayTradeQueryRequestBuilder builder = new AlipayTradeQueryRequestBuilder()
.setOutTradeNo(outTradeNo);
AlipayF2FQueryResult result = tradeService.queryTradeResult(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("查询返回该订单支付成功: )");
AlipayTradeQueryResponse response = result.getResponse();
dumpResponse(response);
log.info(response.getTradeStatus());
if (Utils.isListNotEmpty(response.getFundBillList())) {
for (TradeFundBill bill : response.getFundBillList()) {
log.info(bill.getFundChannel() + ":" + bill.getAmount());
}
}
break;
case FAILED:
log.error("查询返回该订单支付失败或被关闭!!!");
break;
case UNKNOWN:
log.error("系统异常，订单支付状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
// 测试当面付2.0退款
public void test_trade_refund() {
// (必填) 外部订单号，需要退款交易的商户外部订单号
String outTradeNo = "tradepay14817938139942440181";
// (必填) 退款金额，该金额必须小于等于订单的支付金额，单位为元
String refundAmount = "0.01";
// (可选，需要支持重复退货时必填) 商户退款请求号，相同支付宝交易号下的不同退款请求号对应同一笔交易的不同退款申请，
// 对于相同支付宝交易号下多笔相同商户退款请求号的退款交易，支付宝只会进行一次退款
String outRequestNo = "";
// (必填) 退款原因，可以说明用户退款原因，方便为商家后台提供统计
String refundReason = "正常退款，用户买多了";
// (必填) 商户门店编号，退款情况下可以为商家后台提供退款权限判定和统计等作用，详询支付宝技术支持
String storeId = "test_store_id";
// 创建退款请求builder，设置请求参数
AlipayTradeRefundRequestBuilder builder = new AlipayTradeRefundRequestBuilder()
.setOutTradeNo(outTradeNo).setRefundAmount(refundAmount).setRefundReason(refundReason)
.setOutRequestNo(outRequestNo).setStoreId(storeId);
AlipayF2FRefundResult result = tradeService.tradeRefund(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("支付宝退款成功: )");
break;
case FAILED:
log.error("支付宝退款失败!!!");
break;
case UNKNOWN:
log.error("系统异常，订单退款状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
// 测试当面付2.0生成支付二维码
public void test_trade_precreate() {
// (必填) 商户网站订单系统中唯一订单号，64个字符以内，只能包含字母、数字、下划线，
// 需保证商户系统端不能重复，建议通过数据库sequence生成，
String outTradeNo = "tradeprecreate" + System.currentTimeMillis()
+ (long) (Math.random() * 10000000L);
// (必填) 订单标题，粗略描述用户的支付目的。如“xxx品牌xxx门店当面付扫码消费”
String subject = "xxx品牌xxx门店当面付扫码消费";
// (必 <SUF>
// 如果同时传入了【打折金额】,【不可打折金额】,【订单总金额】三者,则必须满足如下条件:【订单总金额】=【打折金额】+【不可打折金额】
String totalAmount = "0.01";
// (可选) 订单不可打折金额，可以配合商家平台配置折扣活动，如果酒水不参与打折，则将对应金额填写至此字段
// 如果该值未传入,但传入了【订单总金额】,【打折金额】,则该值默认为【订单总金额】-【打折金额】
String undiscountableAmount = "0";
// 卖家支付宝账号ID，用于支持一个签约账号下支持打款到不同的收款账号，(打款到sellerId对应的支付宝账号)
// 如果该字段为空，则默认为与支付宝签约的商户的PID，也就是appid对应的PID
String sellerId = "";
// 订单描述，可以对交易或商品进行一个详细地描述，比如填写"购买商品2件共15.00元"
String body = "购买商品3件共20.00元";
// 商户操作员编号，添加此参数可以为商户操作员做销售统计
String operatorId = "test_operator_id";
// (必填) 商户门店编号，通过门店号和商家后台可以配置精准到门店的折扣信息，详询支付宝技术支持
String storeId = "test_store_id";
// 业务扩展参数，目前可添加由支付宝分配的系统商编号(通过setSysServiceProviderId方法)，详情请咨询支付宝技术支持
ExtendParams extendParams = new ExtendParams();
extendParams.setSysServiceProviderId("2088100200300400500");
// 支付超时，定义为120分钟
String timeoutExpress = "120m";
// 商品明细列表，需填写购买商品详细信息，
List<GoodsDetail> goodsDetailList = new ArrayList<GoodsDetail>();
// 创建一个商品信息，参数含义分别为商品id（使用国标）、名称、单价（单位为分）、数量，如果需要添加商品类别，详见GoodsDetail
GoodsDetail goods1 = GoodsDetail.newInstance("goods_id001", "xxx小面包", 1000, 1);
// 创建好一个商品后添加至商品明细列表
goodsDetailList.add(goods1);
// 继续创建并添加第一条商品信息，用户购买的产品为“黑人牙刷”，单价为5.00元，购买了两件
GoodsDetail goods2 = GoodsDetail.newInstance("goods_id002", "xxx牙刷", 500, 2);
goodsDetailList.add(goods2);
// 创建扫码支付请求builder，设置请求参数
AlipayTradePrecreateRequestBuilder builder = new AlipayTradePrecreateRequestBuilder()
.setSubject(subject).setTotalAmount(totalAmount).setOutTradeNo(outTradeNo)
.setUndiscountableAmount(undiscountableAmount).setSellerId(sellerId).setBody(body)
.setOperatorId(operatorId).setStoreId(storeId).setExtendParams(extendParams)
.setTimeoutExpress(timeoutExpress)
// .setNotifyUrl("http://www.test-notify-url.com")//支付宝服务器主动通知商户服务器里指定的页面http路径,根据需要设置
.setGoodsDetailList(goodsDetailList);
AlipayF2FPrecreateResult result = tradeService.tradePrecreate(builder);
switch (result.getTradeStatus()) {
case SUCCESS:
log.info("支付宝预下单成功: )");
AlipayTradePrecreateResponse response = result.getResponse();
dumpResponse(response);
// 需要修改为运行机器上的路径
String filePath = String.format("/Users/sudo/Desktop/qr-%s.png",
response.getOutTradeNo());
log.info("filePath:" + filePath);
// ZxingUtils.getQRCodeImge(response.getQrCode(), 256, filePath);
break;
case FAILED:
log.error("支付宝预下单失败!!!");
break;
case UNKNOWN:
log.error("系统异常，预下单状态未知!!!");
break;
default:
log.error("不支持的交易状态，交易返回异常!!!");
break;
}
}
}
| false |
21515_2 | import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
//哈希表的使用
public class hashtable {
public static Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
//integer：整形
public static void main(String[] args)
{
int[] nums = new int[]{2,7,11,15};
int target = 9;
System.out.println(Arrays.toString(twoSum(nums, target)));
System.out.println("哈希表：" + hashtable);
System.out.println(hashtable.get(2));
}
//最简单明了的方法，类似冒泡排序寻找
// public static int[] twoSum(int[] nums, int target) {
// for (int i = 0 ;i < nums.length ;i++)
// {
// for(int j = i+1 ;j < nums.length ;j++)
// {
// if (nums[i]+nums[j] == target)
// {
// int[] b = new int[]{i,j};
// return b;
// }
// }
// }
//}
//使用哈希表，减低算法复杂度
public static int[] twoSum(int[] nums, int target){
//这里将数组的值当做哈希表的key值了，也就是相当于序号值
for (int i = 0; i < nums.length; ++i) {
if (hashtable.containsKey(target - nums[i])) //检查hashmap中是否有指定的key对应的映射关系
//比如第一次，9-2=7，就是contansKey(7)就是检查是否key = 7是否有对应的value值
{
return new int[]{hashtable.get(target - nums[i]), i};
//返回一个数组，数组的元素就是i和找到的key所对应的值
}
hashtable.put(nums[i], i);// 往找不到就添加元素
}
return new int[0];
}
}
/*
map.get() (hashtable)的过程
1. map.get(key). 首先计算key的hash。
2. 根据hash&(length-1)定位到Node数组中的一个下标。如果该下标的元素(也就是链表/红黑树的第
一个元素)中 key的hash的key本身 都和传入的key相同，则证明找到了元素，直接返回即可。
3.如果第一个元素不是要找的，如果第一个元素的类型是TreeNode，则按照红黑树的查找方法查找
元素，如果不是则证明是链表，按照next指针找下去，直到找到或者到达队尾。
简单的功能就是找到有是否有key(...)中的值，有就返回这个key所对应的value
*/
/*
containsKey() 方法检查 hashMap 中是否存在指定的 key 对应的映射关系。
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// 创建一个 HashMap
HashMap<Integer, String> sites = new HashMap<>();
// 往 HashMap 添加一些元素
sites.put(1, "Google");
sites.put(2, "Runoob");
sites.put(3, "Taobao");
System.out.println("sites HashMap: " + sites);
//检查 key 为 1 是否存在
if(sites.containsKey(1)) {
System.out.println("key 为 1 存在于 sites 中");
}
}
}
输出结果：
sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 为 1 存在于 sites 中
*/ | Llongsf/Java_learning | hashtable.java | 887 | //最简单明了的方法，类似冒泡排序寻找 | line_comment | zh-cn | import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
//哈希表的使用
public class hashtable {
public static Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
//integer：整形
public static void main(String[] args)
{
int[] nums = new int[]{2,7,11,15};
int target = 9;
System.out.println(Arrays.toString(twoSum(nums, target)));
System.out.println("哈希表：" + hashtable);
System.out.println(hashtable.get(2));
}
//最简 <SUF>
// public static int[] twoSum(int[] nums, int target) {
// for (int i = 0 ;i < nums.length ;i++)
// {
// for(int j = i+1 ;j < nums.length ;j++)
// {
// if (nums[i]+nums[j] == target)
// {
// int[] b = new int[]{i,j};
// return b;
// }
// }
// }
//}
//使用哈希表，减低算法复杂度
public static int[] twoSum(int[] nums, int target){
//这里将数组的值当做哈希表的key值了，也就是相当于序号值
for (int i = 0; i < nums.length; ++i) {
if (hashtable.containsKey(target - nums[i])) //检查hashmap中是否有指定的key对应的映射关系
//比如第一次，9-2=7，就是contansKey(7)就是检查是否key = 7是否有对应的value值
{
return new int[]{hashtable.get(target - nums[i]), i};
//返回一个数组，数组的元素就是i和找到的key所对应的值
}
hashtable.put(nums[i], i);// 往找不到就添加元素
}
return new int[0];
}
}
/*
map.get() (hashtable)的过程
1. map.get(key). 首先计算key的hash。
2. 根据hash&(length-1)定位到Node数组中的一个下标。如果该下标的元素(也就是链表/红黑树的第
一个元素)中 key的hash的key本身 都和传入的key相同，则证明找到了元素，直接返回即可。
3.如果第一个元素不是要找的，如果第一个元素的类型是TreeNode，则按照红黑树的查找方法查找
元素，如果不是则证明是链表，按照next指针找下去，直到找到或者到达队尾。
简单的功能就是找到有是否有key(...)中的值，有就返回这个key所对应的value
*/
/*
containsKey() 方法检查 hashMap 中是否存在指定的 key 对应的映射关系。
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// 创建一个 HashMap
HashMap<Integer, String> sites = new HashMap<>();
// 往 HashMap 添加一些元素
sites.put(1, "Google");
sites.put(2, "Runoob");
sites.put(3, "Taobao");
System.out.println("sites HashMap: " + sites);
//检查 key 为 1 是否存在
if(sites.containsKey(1)) {
System.out.println("key 为 1 存在于 sites 中");
}
}
}
输出结果：
sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 为 1 存在于 sites 中
*/ | true |
59098_39 | package com.jcq;
import com.api.Request;
import org.junit.Test;
import org.meowy.cqp.jcq.entity.*;
import org.meowy.cqp.jcq.event.JcqAppAbstract;
import javax.swing.*;
import java.util.Date;
import java.util.TimerTask;
import java.util.Timer;
import java.util.TimerTask;
public class Robot extends JcqAppAbstract implements ICQVer, IMsg, IRequest {
/**
* 打包后将不会调用 请不要在此事件中写其他代码
*
* @return 返回应用的ApiVer、Appid
*/
public String appInfo() {
// 应用AppID,规则见 http://d.cqp.me/Pro/开发/基础信息#appid
String AppID = "com.jcq.robot";// 记住编译后的文件和json也要使用appid做文件名
/**
* 本函数【禁止】处理其他任何代码，以免发生异常情况。
* 如需执行初始化代码请在 startup 事件中执行（Type=1001）。
*/
return CQAPIVER + "," + AppID;
}
/**
* 酷Q启动 (Type=1001)<br>
* 本方法会在酷Q【主线程】中被调用。<br>
* 请在这里执行插件初始化代码。<br>
* 请务必尽快返回本子程序，否则会卡住其他插件以及主程序的加载。
*
* @return 请固定返回0
*/
public int startup() {
// 获取应用数据目录(无需储存数据时，请将此行注释)
// appDirectory = CQ.getAppDirectory();
// 返回如：D:\CoolQ\data\app\org.meowy.cqp.jcq\data\app\com.example.demo\
// 应用的所有数据、配置【必须】存放于此目录，避免给用户带来困扰。
return 0;
}
/**
* 酷Q退出 (Type=1002)<br>
* 本方法会在酷Q【主线程】中被调用。<br>
* 无论本应用是否被启用，本函数都会在酷Q退出前执行一次，请在这里执行插件关闭代码。
*
* @return 请固定返回0，返回后酷Q将很快关闭，请不要再通过线程等方式执行其他代码。
*/
public int exit() {
return 0;
}
/**
* 应用已被启用 (Type=1003)<br>
* 当应用被启用后，将收到此事件。<br>
* 如果酷Q载入时应用已被启用，则在 {@link #startup startup}(Type=1001,酷Q启动) 被调用后，本函数也将被调用一次。<br>
* 如非必要，不建议在这里加载窗口。
*
* @return 请固定返回0。
*/
public int enable() {
enable = true;
Timer timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
int hour=Util.getHour(new Date());
int minute = Util.getMinute(new Date());
if(hour==8&&minute==0){
CQ.sendGroupMsg(621293921L,Request.getMorning());
}else if(hour==10&&minute==0){
CQ.sendGroupMsg(621293921L, Request.itNews());
}else if(hour==14&&minute==0){
CQ.sendGroupMsg(621293921L,Request.getnCoVInfo());
}else if(hour==23&&minute==0){
CQ.sendGroupMsg(621293921L,Request.getNight());
}else{
if(minute ==0)
CQ.sendGroupMsg(621293921L, Request.hotComment());
}
}
}, 0, 1000*60);
return 0;
}
/**
* 应用将被停用 (Type=1004)<br>
* 当应用被停用前，将收到此事件。<br>
* 如果酷Q载入时应用已被停用，则本函数【不会】被调用。<br>
* 无论本应用是否被启用，酷Q关闭前本函数都【不会】被调用。
*
* @return 请固定返回0。
*/
public int disable() {
enable = false;
return 0;
}
public static String randWord(){
String word[]={
"如果你不给自己设限，世界上便没有限制你发挥的篱笆。",
"敢行动，梦想才生动！",
"大智若愚，求知若渴。",
"Take is cheap,Show me your code。",
"博观而约取，厚积而薄发。",
"博学之，审问之，慎思之，明辨之，笃行之",
"不飞则已，一飞冲天；不鸣则已，一鸣惊人",
"穷则独善其身，富则兼济天下",
"Whatever is worth doing is worth doing well",
"Jack of all trades and master of none"};
java.util.Random random=new java.util.Random();
return word[random.nextInt(10)];
}
/**
* 私聊消息 (Type=21)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，11/来自好友 1/来自在线状态 2/来自群 3/来自讨论组
* @param msgId 消息ID
* @param fromQQ 来源QQ
* @param msg 消息内容
* @param font 字体
* @return 返回值*不能*直接返回文本 如果要回复消息，请调用api发送<br>
* 这里 返回 {@link IMsg#MSG_INTERCEPT MSG_INTERCEPT} - 截断本条消息，不再继续处理<br>
* 注意：应用优先级设置为"最高"(10000)时，不得使用本返回值<br>
* 如果不回复消息，交由之后的应用/过滤器处理，这里 返回 {@link IMsg#MSG_IGNORE MSG_IGNORE} - 忽略本条消息
*/
public int privateMsg(int subType, int msgId, long fromQQ, String msg, int font) {
// 这里处理消息
CQ.sendPrivateMsg(fromQQ, "李明哲");
return MSG_IGNORE;
}
/**
* 群消息 (Type=2)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，目前固定为1
* @param msgId 消息ID
* @param fromGroup 来源群号
* @param fromQQ 来源QQ号
* @param fromAnonymous 来源匿名者
* @param msg 消息内容
* @param font 字体
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupMsg(int subType, int msgId, long fromGroup, long fromQQ, String fromAnonymous, String msg,
int font) {
// 如果消息来自匿名者
if (fromQQ == 80000000L && !fromAnonymous.equals("")) {
// 将匿名用户信息放到 anonymous 变量中
Anonymous anonymous = CQ.getAnonymous(fromAnonymous);
}
// 解析CQ码案例 如：[CQ:at,qq=100000]
// 解析CQ码 常用变量为 CC(CQCode) 此变量专为CQ码这种特定格式做了解析和封装
// CC.analysis();// 此方法将CQ码解析为可直接读取的对象
// 解析消息中的QQID
// long qqId = CC.getAt(msg);// 此方法为简便方法，获取第一个CQ:at里的QQ号，错误时为：-1000
// List<Long> qqIds = CC.getAts(msg); // 此方法为获取消息中所有的CQ码对象，错误时返回 已解析的数据
// 解析消息中的图片
// String image = CC.getImage(msg);// 此方法为简便方法，获取第一个CQ:image里的图片数据，错误时打印异常到控制台，返回 null
// String file = CQ.getImage(image);// 获取酷Q 下载的图片地址
// 这里处理消息
if (fromGroup == 621293921L) {
// if(msg.contains(CC.at(CQ.getLoginQQ()))){
// if(msg.contains("疫情最新情况")){
// String real=Util.getNews();
// CQ.sendGroupMsg(fromGroup, CC.at(fromQQ)+real );
// }else{
// String aiCode=Util.Aicode(msg);
// CQ.sendGroupMsg(fromGroup,CC.at(fromQQ)+aiCode.replace(CC.at(CQ.getLoginQQ()),""));
// }
// }
//String message=Util.getNews();
// CQ.sendGroupMsg(fromGroup, CC.at(fromQQ) + """ );
}
return MSG_IGNORE;
}
/**
* 讨论组消息 (Type=4)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，目前固定为1
* @param msgId 消息ID
* @param fromDiscuss 来源讨论组
* @param fromQQ 来源QQ号
* @param msg 消息内容
* @param font 字体
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int discussMsg(int subtype, int msgId, long fromDiscuss, long fromQQ, String msg, int font) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群文件上传事件 (Type=11)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，目前固定为1
* @param sendTime 发送时间(时间戳)// 10位时间戳
* @param fromGroup 来源群号
* @param fromQQ 来源QQ号
* @param file 上传文件信息
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupUpload(int subType, int sendTime, long fromGroup, long fromQQ, String file) {
GroupFile groupFile = CQ.getGroupFile(file);
if (groupFile == null) { // 解析群文件信息，如果失败直接忽略该消息
return MSG_IGNORE;
}
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群事件-管理员变动 (Type=101)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/被取消管理员 2/被设置管理员
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param beingOperateQQ 被操作QQ
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupAdmin(int subtype, int sendTime, long fromGroup, long beingOperateQQ) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群事件-群成员减少 (Type=102)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/群员离开 2/群员被踢
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 操作者QQ(仅子类型为2时存在)
* @param beingOperateQQ 被操作QQ
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupMemberDecrease(int subtype, int sendTime, long fromGroup, long fromQQ, long beingOperateQQ) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群事件-群成员增加 (Type=103)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/管理员已同意 2/管理员邀请
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 操作者QQ(即管理员QQ)
* @param beingOperateQQ 被操作QQ(即加群的QQ)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupMemberIncrease(int subtype, int sendTime, long fromGroup, long fromQQ, long beingOperateQQ) {
// 这里处理消息
CQ.logInfo("fromGroup", "" + fromGroup);
CQ.logInfo("fromQQ", "" + fromQQ);
CQ.logInfo("beingOperateQQ", "" + beingOperateQQ);
return MSG_IGNORE;
}
/**
* 群事件-群禁言 (Type=104)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，1/被解禁 2/被禁言
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 操作者QQ
* @param beingOperateQQ 被操作QQ(若为全群禁言/解禁，则本参数为 0)
* @param duration 禁言时长(单位 秒，仅子类型为2时可用)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupBan(int subType, int sendTime, long fromGroup, long fromQQ, long beingOperateQQ, long duration) {
// 这里处理消息
return 0;
}
/**
* 好友事件-好友已添加 (Type=201)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，目前固定为1
* @param sendTime 发送时间(时间戳)
* @param fromQQ 来源QQ
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int friendAdd(int subtype, int sendTime, long fromQQ) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 请求-好友添加 (Type=301)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，目前固定为1
* @param sendTime 发送时间(时间戳)
* @param fromQQ 来源QQ
* @param msg 附言
* @param responseFlag 反馈标识(处理请求用)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int requestAddFriend(int subtype, int sendTime, long fromQQ, String msg, String responseFlag) {
// 这里处理消息
/**
* REQUEST_ADOPT 通过
* REQUEST_REFUSE 拒绝
*/
// CQ.setFriendAddRequest(responseFlag, REQUEST_ADOPT, null); // 同意好友添加请求
return MSG_IGNORE;
}
/**
* 请求-群添加 (Type=302)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/他人申请入群 2/自己(即登录号)受邀入群
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 来源QQ
* @param msg 附言
* @param responseFlag 反馈标识(处理请求用)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int requestAddGroup(int subtype, int sendTime, long fromGroup, long fromQQ, String msg,
String responseFlag) {
// 这里处理消息
/**
* REQUEST_ADOPT 通过
* REQUEST_REFUSE 拒绝
* REQUEST_GROUP_ADD 群添加
* REQUEST_GROUP_INVITE 群邀请
*/
/*if(subtype == 1){ // 本号为群管理，判断是否为他人申请入群
CQ.setGroupAddRequest(responseFlag, REQUEST_GROUP_ADD, REQUEST_ADOPT, null);// 同意入群
}
if(subtype == 2){
CQ.setGroupAddRequest(responseFlag, REQUEST_GROUP_INVITE, REQUEST_ADOPT, null);// 同意进受邀群
}*/
return MSG_IGNORE;
}
/**
* 本函数会在JCQ【线程】中被调用。
*
* @return 固定返回0
*/
public int menuA() {
JOptionPane.showMessageDialog(null, "这是测试菜单A，可以在这里加载窗口");
return 0;
}
/**
* 本函数会在酷Q【线程】中被调用。
*
* @return 固定返回0
*/
public int menuB() {
JOptionPane.showMessageDialog(null, "这是测试菜单B，可以在这里加载窗口");
return 0;
}
} | LmyFreeMan/Robot | src/main/java/com/jcq/Robot.java | 4,326 | // 解析群文件信息，如果失败直接忽略该消息 | line_comment | zh-cn | package com.jcq;
import com.api.Request;
import org.junit.Test;
import org.meowy.cqp.jcq.entity.*;
import org.meowy.cqp.jcq.event.JcqAppAbstract;
import javax.swing.*;
import java.util.Date;
import java.util.TimerTask;
import java.util.Timer;
import java.util.TimerTask;
public class Robot extends JcqAppAbstract implements ICQVer, IMsg, IRequest {
/**
* 打包后将不会调用 请不要在此事件中写其他代码
*
* @return 返回应用的ApiVer、Appid
*/
public String appInfo() {
// 应用AppID,规则见 http://d.cqp.me/Pro/开发/基础信息#appid
String AppID = "com.jcq.robot";// 记住编译后的文件和json也要使用appid做文件名
/**
* 本函数【禁止】处理其他任何代码，以免发生异常情况。
* 如需执行初始化代码请在 startup 事件中执行（Type=1001）。
*/
return CQAPIVER + "," + AppID;
}
/**
* 酷Q启动 (Type=1001)<br>
* 本方法会在酷Q【主线程】中被调用。<br>
* 请在这里执行插件初始化代码。<br>
* 请务必尽快返回本子程序，否则会卡住其他插件以及主程序的加载。
*
* @return 请固定返回0
*/
public int startup() {
// 获取应用数据目录(无需储存数据时，请将此行注释)
// appDirectory = CQ.getAppDirectory();
// 返回如：D:\CoolQ\data\app\org.meowy.cqp.jcq\data\app\com.example.demo\
// 应用的所有数据、配置【必须】存放于此目录，避免给用户带来困扰。
return 0;
}
/**
* 酷Q退出 (Type=1002)<br>
* 本方法会在酷Q【主线程】中被调用。<br>
* 无论本应用是否被启用，本函数都会在酷Q退出前执行一次，请在这里执行插件关闭代码。
*
* @return 请固定返回0，返回后酷Q将很快关闭，请不要再通过线程等方式执行其他代码。
*/
public int exit() {
return 0;
}
/**
* 应用已被启用 (Type=1003)<br>
* 当应用被启用后，将收到此事件。<br>
* 如果酷Q载入时应用已被启用，则在 {@link #startup startup}(Type=1001,酷Q启动) 被调用后，本函数也将被调用一次。<br>
* 如非必要，不建议在这里加载窗口。
*
* @return 请固定返回0。
*/
public int enable() {
enable = true;
Timer timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
int hour=Util.getHour(new Date());
int minute = Util.getMinute(new Date());
if(hour==8&&minute==0){
CQ.sendGroupMsg(621293921L,Request.getMorning());
}else if(hour==10&&minute==0){
CQ.sendGroupMsg(621293921L, Request.itNews());
}else if(hour==14&&minute==0){
CQ.sendGroupMsg(621293921L,Request.getnCoVInfo());
}else if(hour==23&&minute==0){
CQ.sendGroupMsg(621293921L,Request.getNight());
}else{
if(minute ==0)
CQ.sendGroupMsg(621293921L, Request.hotComment());
}
}
}, 0, 1000*60);
return 0;
}
/**
* 应用将被停用 (Type=1004)<br>
* 当应用被停用前，将收到此事件。<br>
* 如果酷Q载入时应用已被停用，则本函数【不会】被调用。<br>
* 无论本应用是否被启用，酷Q关闭前本函数都【不会】被调用。
*
* @return 请固定返回0。
*/
public int disable() {
enable = false;
return 0;
}
public static String randWord(){
String word[]={
"如果你不给自己设限，世界上便没有限制你发挥的篱笆。",
"敢行动，梦想才生动！",
"大智若愚，求知若渴。",
"Take is cheap,Show me your code。",
"博观而约取，厚积而薄发。",
"博学之，审问之，慎思之，明辨之，笃行之",
"不飞则已，一飞冲天；不鸣则已，一鸣惊人",
"穷则独善其身，富则兼济天下",
"Whatever is worth doing is worth doing well",
"Jack of all trades and master of none"};
java.util.Random random=new java.util.Random();
return word[random.nextInt(10)];
}
/**
* 私聊消息 (Type=21)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，11/来自好友 1/来自在线状态 2/来自群 3/来自讨论组
* @param msgId 消息ID
* @param fromQQ 来源QQ
* @param msg 消息内容
* @param font 字体
* @return 返回值*不能*直接返回文本 如果要回复消息，请调用api发送<br>
* 这里 返回 {@link IMsg#MSG_INTERCEPT MSG_INTERCEPT} - 截断本条消息，不再继续处理<br>
* 注意：应用优先级设置为"最高"(10000)时，不得使用本返回值<br>
* 如果不回复消息，交由之后的应用/过滤器处理，这里 返回 {@link IMsg#MSG_IGNORE MSG_IGNORE} - 忽略本条消息
*/
public int privateMsg(int subType, int msgId, long fromQQ, String msg, int font) {
// 这里处理消息
CQ.sendPrivateMsg(fromQQ, "李明哲");
return MSG_IGNORE;
}
/**
* 群消息 (Type=2)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，目前固定为1
* @param msgId 消息ID
* @param fromGroup 来源群号
* @param fromQQ 来源QQ号
* @param fromAnonymous 来源匿名者
* @param msg 消息内容
* @param font 字体
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupMsg(int subType, int msgId, long fromGroup, long fromQQ, String fromAnonymous, String msg,
int font) {
// 如果消息来自匿名者
if (fromQQ == 80000000L && !fromAnonymous.equals("")) {
// 将匿名用户信息放到 anonymous 变量中
Anonymous anonymous = CQ.getAnonymous(fromAnonymous);
}
// 解析CQ码案例 如：[CQ:at,qq=100000]
// 解析CQ码 常用变量为 CC(CQCode) 此变量专为CQ码这种特定格式做了解析和封装
// CC.analysis();// 此方法将CQ码解析为可直接读取的对象
// 解析消息中的QQID
// long qqId = CC.getAt(msg);// 此方法为简便方法，获取第一个CQ:at里的QQ号，错误时为：-1000
// List<Long> qqIds = CC.getAts(msg); // 此方法为获取消息中所有的CQ码对象，错误时返回 已解析的数据
// 解析消息中的图片
// String image = CC.getImage(msg);// 此方法为简便方法，获取第一个CQ:image里的图片数据，错误时打印异常到控制台，返回 null
// String file = CQ.getImage(image);// 获取酷Q 下载的图片地址
// 这里处理消息
if (fromGroup == 621293921L) {
// if(msg.contains(CC.at(CQ.getLoginQQ()))){
// if(msg.contains("疫情最新情况")){
// String real=Util.getNews();
// CQ.sendGroupMsg(fromGroup, CC.at(fromQQ)+real );
// }else{
// String aiCode=Util.Aicode(msg);
// CQ.sendGroupMsg(fromGroup,CC.at(fromQQ)+aiCode.replace(CC.at(CQ.getLoginQQ()),""));
// }
// }
//String message=Util.getNews();
// CQ.sendGroupMsg(fromGroup, CC.at(fromQQ) + """ );
}
return MSG_IGNORE;
}
/**
* 讨论组消息 (Type=4)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，目前固定为1
* @param msgId 消息ID
* @param fromDiscuss 来源讨论组
* @param fromQQ 来源QQ号
* @param msg 消息内容
* @param font 字体
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int discussMsg(int subtype, int msgId, long fromDiscuss, long fromQQ, String msg, int font) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群文件上传事件 (Type=11)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，目前固定为1
* @param sendTime 发送时间(时间戳)// 10位时间戳
* @param fromGroup 来源群号
* @param fromQQ 来源QQ号
* @param file 上传文件信息
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupUpload(int subType, int sendTime, long fromGroup, long fromQQ, String file) {
GroupFile groupFile = CQ.getGroupFile(file);
if (groupFile == null) { // 解析 <SUF>
return MSG_IGNORE;
}
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群事件-管理员变动 (Type=101)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/被取消管理员 2/被设置管理员
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param beingOperateQQ 被操作QQ
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupAdmin(int subtype, int sendTime, long fromGroup, long beingOperateQQ) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群事件-群成员减少 (Type=102)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/群员离开 2/群员被踢
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 操作者QQ(仅子类型为2时存在)
* @param beingOperateQQ 被操作QQ
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupMemberDecrease(int subtype, int sendTime, long fromGroup, long fromQQ, long beingOperateQQ) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 群事件-群成员增加 (Type=103)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/管理员已同意 2/管理员邀请
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 操作者QQ(即管理员QQ)
* @param beingOperateQQ 被操作QQ(即加群的QQ)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupMemberIncrease(int subtype, int sendTime, long fromGroup, long fromQQ, long beingOperateQQ) {
// 这里处理消息
CQ.logInfo("fromGroup", "" + fromGroup);
CQ.logInfo("fromQQ", "" + fromQQ);
CQ.logInfo("beingOperateQQ", "" + beingOperateQQ);
return MSG_IGNORE;
}
/**
* 群事件-群禁言 (Type=104)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subType 子类型，1/被解禁 2/被禁言
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 操作者QQ
* @param beingOperateQQ 被操作QQ(若为全群禁言/解禁，则本参数为 0)
* @param duration 禁言时长(单位 秒，仅子类型为2时可用)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int groupBan(int subType, int sendTime, long fromGroup, long fromQQ, long beingOperateQQ, long duration) {
// 这里处理消息
return 0;
}
/**
* 好友事件-好友已添加 (Type=201)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，目前固定为1
* @param sendTime 发送时间(时间戳)
* @param fromQQ 来源QQ
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int friendAdd(int subtype, int sendTime, long fromQQ) {
// 这里处理消息
return MSG_IGNORE;
}
/**
* 请求-好友添加 (Type=301)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，目前固定为1
* @param sendTime 发送时间(时间戳)
* @param fromQQ 来源QQ
* @param msg 附言
* @param responseFlag 反馈标识(处理请求用)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int requestAddFriend(int subtype, int sendTime, long fromQQ, String msg, String responseFlag) {
// 这里处理消息
/**
* REQUEST_ADOPT 通过
* REQUEST_REFUSE 拒绝
*/
// CQ.setFriendAddRequest(responseFlag, REQUEST_ADOPT, null); // 同意好友添加请求
return MSG_IGNORE;
}
/**
* 请求-群添加 (Type=302)<br>
* 本方法会在酷Q【线程】中被调用。<br>
*
* @param subtype 子类型，1/他人申请入群 2/自己(即登录号)受邀入群
* @param sendTime 发送时间(时间戳)
* @param fromGroup 来源群号
* @param fromQQ 来源QQ
* @param msg 附言
* @param responseFlag 反馈标识(处理请求用)
* @return 关于返回值说明, 见 {@link #privateMsg 私聊消息} 的方法
*/
public int requestAddGroup(int subtype, int sendTime, long fromGroup, long fromQQ, String msg,
String responseFlag) {
// 这里处理消息
/**
* REQUEST_ADOPT 通过
* REQUEST_REFUSE 拒绝
* REQUEST_GROUP_ADD 群添加
* REQUEST_GROUP_INVITE 群邀请
*/
/*if(subtype == 1){ // 本号为群管理，判断是否为他人申请入群
CQ.setGroupAddRequest(responseFlag, REQUEST_GROUP_ADD, REQUEST_ADOPT, null);// 同意入群
}
if(subtype == 2){
CQ.setGroupAddRequest(responseFlag, REQUEST_GROUP_INVITE, REQUEST_ADOPT, null);// 同意进受邀群
}*/
return MSG_IGNORE;
}
/**
* 本函数会在JCQ【线程】中被调用。
*
* @return 固定返回0
*/
public int menuA() {
JOptionPane.showMessageDialog(null, "这是测试菜单A，可以在这里加载窗口");
return 0;
}
/**
* 本函数会在酷Q【线程】中被调用。
*
* @return 固定返回0
*/
public int menuB() {
JOptionPane.showMessageDialog(null, "这是测试菜单B，可以在这里加载窗口");
return 0;
}
} | true |
20028_8 |
//QQ登录界面制作
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class MainWindow extends JFrame {
//public static String[] IDs=new String[100];
// 北部区域
JLabel jl1;
// 南部区域
JButton jb1, jb2, jb3;
JPanel jp1;
// 中部区域
static JTabbedPane jtp;// 选项卡窗格
static JPanel jp2, jp3, jp4;
JLabel jl2, jl3, jl4, jl5;
// 号码输入文本框
JTextField jtf;
// 密码
JPasswordField jpf;
// 清除号码
JButton jb4;
// 隐身登录、记住密码
JCheckBox jcb1, jcb2;
public static void main(String[] args) {
// new WelcomeWindow();
// if(demo2.check_new()){
// new WelcomeWindow();
// }
//
// // TODO Auto-generated method stub
// else {
new MainWindow();
// }
}
public MainWindow() {
System.out.println("进入 MainWindow 方法 ，无输入， 无输出");
// // 创建组件
// jl2 = new JLabel("QQ号码", JLabel.CENTER);
// jl3 = new JLabel("QQ密码", JLabel.CENTER);
// jl4 = new JLabel("忘记密码", JLabel.CENTER);
// jl4.setFont(new Font("宋体", Font.PLAIN, 16));// 设置字体样式
// jl4.setForeground(Color.BLUE);// 设置字体颜色
// jl5 = new JLabel("<html><a href='www.qq.com'>申请密码保护</a></html>");
// // 鼠标触发变化
// jl5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
//
// jtf = new JTextField();
// jpf = new JPasswordField();
// jb4 = new JButton(new ImageIcon("images\\login.png"));
//
// jcb1 = new JCheckBox("隐身登录");
// jcb2 = new JCheckBox("记住密码");
// // 北部区域
// jl1 = new JLabel(new ImageIcon("images\\headpicture.jpg"));
//
// // 南部区域
// jp1 = new JPanel();
// jb1 = new JButton(new ImageIcon("images\\login.png"));
// jb2 = new JButton(new ImageIcon("images\\delete.png"));
// jb3 = new JButton(new ImageIcon("images\\register.png"));
// 中部区域
jtp = new JTabbedPane();
jp2 = new JPanel();
jp3 = new JPanel();
//jp3.setBackground(Color.RED);// 给面板设置背景
jp4 = new JPanel();
//jp4.setBackground(new Color(0, 0, 0));
// 将面板添加到选项卡窗格上
jtp.add("今日提醒", jp2);// 参数：选项卡名称，面板
jtp.add("今日买药", jp3);
jtp.add("查询", jp4);
/**
*
*
* search_infos[0]=name;
* search_infos[1]=gender;
* search_infos[2]=ID;
* search_infos[3]=phone;
* search_infos[4]=medical;
* search_infos[5]=disease_type;
* search_infos[6]=insurance_type;
* search_infos[7]=address;
*/
// 设置布局
//jp2.setLayout(new GridLayout(3, 3));
// 添加组件
// jp1.add(jb1);
// jp1.add(jb2);
// jp1.add(jb3);
//
// jp2.add(jl2);
// jp2.add(jtf);
// jp2.add(jb4);
// jp2.add(jl3);
// jp2.add(jpf);
// jp2.add(jl4);
// jp2.add(jcb1);
// jp2.add(jcb2);
// jp2.add(jl5);
jp2= MainWindow_Labels.noti_buy(jp2,"noti",null);//第一个页面
// int first_time=0;
jtp.addChangeListener(new ChangeListener() {//可以每点一下就刷新，
@Override
public void stateChanged(ChangeEvent e) {
// TODO Auto-generated method stub
int selectedIndex = jtp.getSelectedIndex();//获得被选中选项卡的索引
String title = jtp.getTitleAt(selectedIndex);//获得指定索引的选项卡标签
System.out.println(title);
if(title.equals("今日提醒")){
jp2= MainWindow_Labels.noti_buy(jp2,"noti",null);
//jp3= MainWindow_Labels.noti_buy(jp3,"buy",null);
}else if(title.equals("今日买药")){
//jp2= MainWindow_Labels.noti_buy(jp2,"noti",null);
jp3= MainWindow_Labels.noti_buy(jp3,"buy",null);
}else if(title.equals("查询")){
// if(first_time==0){
// jp4= MainWindow_Labels.noti_buy(jp4,"search",null);
//
// }
// first_time=1;
//jp4= MainWindow_Labels.noti_buy(jp4,"search",null);
//SecondWindow.User_Detail_Imformation("search",null);
}
}
});
// String[] columnNames = {"姓名","性别","号主+号码","药名","预计用药时间","预计用药次数","上次备注情况"}; //列名
// String [][]tableVales={{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"}}; //数据
// tableModel = new DefaultTableModel(tableVales,columnNames);
// table = new JTable(tableModel);
// JScrollPane scrollPane = new JScrollPane(table); //支持滚动
// //getContentPane().add(scrollPane,BorderLayout.CENTER);
// //jdk1.6
// //排序:
// //table.setRowSorter(new TableRowSorter(tableModel));
// table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); //单选
// table.addMouseListener(new MouseAdapter(){ //鼠标事件
// public void mouseClicked(MouseEvent e){
// int selectedRow = table.getSelectedRow(); //获得选中行索引
// Object oa = tableModel.getValueAt(selectedRow, 0);
// Object ob = tableModel.getValueAt(selectedRow, 1);
// aTextField.setText(oa.toString()); //给文本框赋值
// bTextField.setText(ob.toString());
// }
// });
// scrollPane.setViewportView(table);
//
// //final JPanel jp2 = new JPanel();
// //getContentPane().add(jp2,BorderLayout.SOUTH);
// jp2.setLayout(new GridLayout(1,1));
// jp2.add(scrollPane);
//
//菜单
JMenuBar jmb= MainWindow_Menu.menu();
this.setJMenuBar(jmb);
/*
jp2.add(new JLabel("A: "));
aTextField = new JTextField("A4",10);
jp2.add(aTextField);
jp2.add(new JLabel("B: "));
bTextField = new JTextField("B4",10);
jp2.add(bTextField);
final JButton addButton = new JButton("添加"); //添加按钮
addButton.addActionListener(new ActionListener(){//添加事件
public void actionPerformed(ActionEvent e){
String []rowValues = {aTextField.getText(),bTextField.getText()};
tableModel.addRow(rowValues); //添加一行
int rowCount = table.getRowCount() +1; //行数加上1
aTextField.setText("A"+rowCount);
bTextField.setText("B"+rowCount);
}
});
jp2.add(addButton);
final JButton updateButton = new JButton("修改"); //修改按钮
updateButton.addActionListener(new ActionListener(){//添加事件
public void actionPerformed(ActionEvent e){
int selectedRow = table.getSelectedRow();//获得选中行的索引
if(selectedRow!= -1) //是否存在选中行
{
//修改指定的值：
tableModel.setValueAt(aTextField.getText(), selectedRow, 0);
tableModel.setValueAt(bTextField.getText(), selectedRow, 1);
//table.setValueAt(arg0, arg1, arg2)
}
}
});
jp2.add(updateButton);
final JButton delButton = new JButton("删除");
delButton.addActionListener(new ActionListener(){//添加事件
public void actionPerformed(ActionEvent e){
int selectedRow = table.getSelectedRow();//获得选中行的索引
if(selectedRow!=-1) //存在选中行
{
tableModel.removeRow(selectedRow); //删除行
}
}
});
jp2.add(delButton);
*/
// this.add(jp1, BorderLayout.SOUTH);
// this.add(jl1, BorderLayout.NORTH);
this.add(jtp, BorderLayout.CENTER);
// 展示组件
// ImageIcon icon = new ImageIcon("images\\qq.png");
// this.setIconImage(icon.getImage());// 给窗体设置图标方法
this.setSize(1200, 700);
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.setTitle("诚管系统");
this.setVisible(true);
//this.Update(this.getGraphics());
// for(int i=0;i<=1000;i++) {
// this.repaint();
// }
//getToday();
}
public static void repaintFrame(){
//Frame.repaint();
}
} | LoadingLoading/Phamacy-Users-Imformation-Management-System | src/MainWindow.java | 2,665 | // 隐身登录、记住密码 | line_comment | zh-cn |
//QQ登录界面制作
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class MainWindow extends JFrame {
//public static String[] IDs=new String[100];
// 北部区域
JLabel jl1;
// 南部区域
JButton jb1, jb2, jb3;
JPanel jp1;
// 中部区域
static JTabbedPane jtp;// 选项卡窗格
static JPanel jp2, jp3, jp4;
JLabel jl2, jl3, jl4, jl5;
// 号码输入文本框
JTextField jtf;
// 密码
JPasswordField jpf;
// 清除号码
JButton jb4;
// 隐身 <SUF>
JCheckBox jcb1, jcb2;
public static void main(String[] args) {
// new WelcomeWindow();
// if(demo2.check_new()){
// new WelcomeWindow();
// }
//
// // TODO Auto-generated method stub
// else {
new MainWindow();
// }
}
public MainWindow() {
System.out.println("进入 MainWindow 方法 ，无输入， 无输出");
// // 创建组件
// jl2 = new JLabel("QQ号码", JLabel.CENTER);
// jl3 = new JLabel("QQ密码", JLabel.CENTER);
// jl4 = new JLabel("忘记密码", JLabel.CENTER);
// jl4.setFont(new Font("宋体", Font.PLAIN, 16));// 设置字体样式
// jl4.setForeground(Color.BLUE);// 设置字体颜色
// jl5 = new JLabel("<html><a href='www.qq.com'>申请密码保护</a></html>");
// // 鼠标触发变化
// jl5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
//
// jtf = new JTextField();
// jpf = new JPasswordField();
// jb4 = new JButton(new ImageIcon("images\\login.png"));
//
// jcb1 = new JCheckBox("隐身登录");
// jcb2 = new JCheckBox("记住密码");
// // 北部区域
// jl1 = new JLabel(new ImageIcon("images\\headpicture.jpg"));
//
// // 南部区域
// jp1 = new JPanel();
// jb1 = new JButton(new ImageIcon("images\\login.png"));
// jb2 = new JButton(new ImageIcon("images\\delete.png"));
// jb3 = new JButton(new ImageIcon("images\\register.png"));
// 中部区域
jtp = new JTabbedPane();
jp2 = new JPanel();
jp3 = new JPanel();
//jp3.setBackground(Color.RED);// 给面板设置背景
jp4 = new JPanel();
//jp4.setBackground(new Color(0, 0, 0));
// 将面板添加到选项卡窗格上
jtp.add("今日提醒", jp2);// 参数：选项卡名称，面板
jtp.add("今日买药", jp3);
jtp.add("查询", jp4);
/**
*
*
* search_infos[0]=name;
* search_infos[1]=gender;
* search_infos[2]=ID;
* search_infos[3]=phone;
* search_infos[4]=medical;
* search_infos[5]=disease_type;
* search_infos[6]=insurance_type;
* search_infos[7]=address;
*/
// 设置布局
//jp2.setLayout(new GridLayout(3, 3));
// 添加组件
// jp1.add(jb1);
// jp1.add(jb2);
// jp1.add(jb3);
//
// jp2.add(jl2);
// jp2.add(jtf);
// jp2.add(jb4);
// jp2.add(jl3);
// jp2.add(jpf);
// jp2.add(jl4);
// jp2.add(jcb1);
// jp2.add(jcb2);
// jp2.add(jl5);
jp2= MainWindow_Labels.noti_buy(jp2,"noti",null);//第一个页面
// int first_time=0;
jtp.addChangeListener(new ChangeListener() {//可以每点一下就刷新，
@Override
public void stateChanged(ChangeEvent e) {
// TODO Auto-generated method stub
int selectedIndex = jtp.getSelectedIndex();//获得被选中选项卡的索引
String title = jtp.getTitleAt(selectedIndex);//获得指定索引的选项卡标签
System.out.println(title);
if(title.equals("今日提醒")){
jp2= MainWindow_Labels.noti_buy(jp2,"noti",null);
//jp3= MainWindow_Labels.noti_buy(jp3,"buy",null);
}else if(title.equals("今日买药")){
//jp2= MainWindow_Labels.noti_buy(jp2,"noti",null);
jp3= MainWindow_Labels.noti_buy(jp3,"buy",null);
}else if(title.equals("查询")){
// if(first_time==0){
// jp4= MainWindow_Labels.noti_buy(jp4,"search",null);
//
// }
// first_time=1;
//jp4= MainWindow_Labels.noti_buy(jp4,"search",null);
//SecondWindow.User_Detail_Imformation("search",null);
}
}
});
// String[] columnNames = {"姓名","性别","号主+号码","药名","预计用药时间","预计用药次数","上次备注情况"}; //列名
// String [][]tableVales={{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"},{"XXX","男","XXX 188 8888 8888","凯美纳","2019年6月20号","第3次","无"}}; //数据
// tableModel = new DefaultTableModel(tableVales,columnNames);
// table = new JTable(tableModel);
// JScrollPane scrollPane = new JScrollPane(table); //支持滚动
// //getContentPane().add(scrollPane,BorderLayout.CENTER);
// //jdk1.6
// //排序:
// //table.setRowSorter(new TableRowSorter(tableModel));
// table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); //单选
// table.addMouseListener(new MouseAdapter(){ //鼠标事件
// public void mouseClicked(MouseEvent e){
// int selectedRow = table.getSelectedRow(); //获得选中行索引
// Object oa = tableModel.getValueAt(selectedRow, 0);
// Object ob = tableModel.getValueAt(selectedRow, 1);
// aTextField.setText(oa.toString()); //给文本框赋值
// bTextField.setText(ob.toString());
// }
// });
// scrollPane.setViewportView(table);
//
// //final JPanel jp2 = new JPanel();
// //getContentPane().add(jp2,BorderLayout.SOUTH);
// jp2.setLayout(new GridLayout(1,1));
// jp2.add(scrollPane);
//
//菜单
JMenuBar jmb= MainWindow_Menu.menu();
this.setJMenuBar(jmb);
/*
jp2.add(new JLabel("A: "));
aTextField = new JTextField("A4",10);
jp2.add(aTextField);
jp2.add(new JLabel("B: "));
bTextField = new JTextField("B4",10);
jp2.add(bTextField);
final JButton addButton = new JButton("添加"); //添加按钮
addButton.addActionListener(new ActionListener(){//添加事件
public void actionPerformed(ActionEvent e){
String []rowValues = {aTextField.getText(),bTextField.getText()};
tableModel.addRow(rowValues); //添加一行
int rowCount = table.getRowCount() +1; //行数加上1
aTextField.setText("A"+rowCount);
bTextField.setText("B"+rowCount);
}
});
jp2.add(addButton);
final JButton updateButton = new JButton("修改"); //修改按钮
updateButton.addActionListener(new ActionListener(){//添加事件
public void actionPerformed(ActionEvent e){
int selectedRow = table.getSelectedRow();//获得选中行的索引
if(selectedRow!= -1) //是否存在选中行
{
//修改指定的值：
tableModel.setValueAt(aTextField.getText(), selectedRow, 0);
tableModel.setValueAt(bTextField.getText(), selectedRow, 1);
//table.setValueAt(arg0, arg1, arg2)
}
}
});
jp2.add(updateButton);
final JButton delButton = new JButton("删除");
delButton.addActionListener(new ActionListener(){//添加事件
public void actionPerformed(ActionEvent e){
int selectedRow = table.getSelectedRow();//获得选中行的索引
if(selectedRow!=-1) //存在选中行
{
tableModel.removeRow(selectedRow); //删除行
}
}
});
jp2.add(delButton);
*/
// this.add(jp1, BorderLayout.SOUTH);
// this.add(jl1, BorderLayout.NORTH);
this.add(jtp, BorderLayout.CENTER);
// 展示组件
// ImageIcon icon = new ImageIcon("images\\qq.png");
// this.setIconImage(icon.getImage());// 给窗体设置图标方法
this.setSize(1200, 700);
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.setTitle("诚管系统");
this.setVisible(true);
//this.Update(this.getGraphics());
// for(int i=0;i<=1000;i++) {
// this.repaint();
// }
//getToday();
}
public static void repaintFrame(){
//Frame.repaint();
}
} | true |
18872_7 | //计划:当玩家输入/tgame join 时加入游戏
//输入/tgame quit时退出游戏
//有两个队,1v1
//杀一个人得一分
//注意，改插件版本为1.11.2，如果有其他要求请在下面删除CommandManager
import com.locydragon.gamelib.api.CustomGame;
import com.locydragon.gamelib.api.GameLibrary;
import com.locydragon.gamelib.api.entity.PlayingPlayer;
import com.locydragon.gamelib.api.event.baby.bukkitevents.GamePlayerDamageEntityEvent;
import com.locydragon.gamelib.api.event.baby.bukkitevents.GamePlayerDeathEvent;
import com.locydragon.gamelib.api.event.type.EventType;
import com.locydragon.gamelib.api.util.CommandManager;
import com.locydragon.gamelib.api.util.ScoreManager;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
/**
* @author LocyDragon
* This is only a example!You can use this code anyway!
*/
public class TestGame extends JavaPlugin {
CustomGame game = null;
//游戏
ScoreManager manager = null;
//积分器
@Override
public void onEnable() {
game = GameLibrary.getLibrary().setMaxPlayerInOneTeam(1)
//设置每队最多的人数
.teamNumber(2)
//设置队数量
.build()
//生成Game实例对象
.addEvent(EventType.PLAYING_PLAYER_DEATH, gameEvent -> {
GamePlayerDeathEvent event = (GamePlayerDeathEvent)gameEvent;
//这里可以强转
PlayingPlayer player = PlayingPlayer.search(event.getProp().getEntity().getKiller());
//获取PlayingPlayer实例对象
if (player.getGame() == null || player.getTeam() == -1) {
//检查一下杀人者是否在游戏当中
return;
}
manager.addOneScore(player.getTeam());
//加一分
game.broadcastMsg(ChatColor.RED+player.getPlayerName()+"杀死了"+event.getProp().getEntity().getName());
//广播杀敌信息
game.broadcastMsg(ChatColor.RED+"目前组"+event.getPlayer().getTeam()+"分数: "+manager.getScore(player.getTeam()));
//广播分数
})
.addEvent(EventType.ON_GAME_JOIN, gameEvent -> {
((Player)gameEvent.getPlayer()).sendMessage("你进入了游戏.");
//凡是以"ON"开头的事件都得转成Player，其他转成PlayingPlayer即可
})
.addEvent(EventType.ON_GAME_QUIT, gameEvent -> {
((Player)gameEvent.getPlayer()).sendMessage("你退出了游戏.");
//凡是以"ON"开头的事件都得转成Player，其他转成PlayingPlayer即可
})
.startGame(); //开始游戏
manager = new ScoreManager(game);
//实例化积分器对象
new CommandManager("tgame") //这是为了方便快速注册指令
.bindJoinCmd("join", this.game)
//快速加入游戏指令，不过不推荐这么做
.bindQuitCmd("quit", this.game);
//快速设置退出游戏指令
//注意: CommandManager仅在1.11.2以下版本奏效，若高于这个版本会报错。
//结果方案:自行注册指令
}
}
| LocyDragon/GameLib | TestGame.java | 876 | //设置每队最多的人数 | line_comment | zh-cn | //计划:当玩家输入/tgame join 时加入游戏
//输入/tgame quit时退出游戏
//有两个队,1v1
//杀一个人得一分
//注意，改插件版本为1.11.2，如果有其他要求请在下面删除CommandManager
import com.locydragon.gamelib.api.CustomGame;
import com.locydragon.gamelib.api.GameLibrary;
import com.locydragon.gamelib.api.entity.PlayingPlayer;
import com.locydragon.gamelib.api.event.baby.bukkitevents.GamePlayerDamageEntityEvent;
import com.locydragon.gamelib.api.event.baby.bukkitevents.GamePlayerDeathEvent;
import com.locydragon.gamelib.api.event.type.EventType;
import com.locydragon.gamelib.api.util.CommandManager;
import com.locydragon.gamelib.api.util.ScoreManager;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
/**
* @author LocyDragon
* This is only a example!You can use this code anyway!
*/
public class TestGame extends JavaPlugin {
CustomGame game = null;
//游戏
ScoreManager manager = null;
//积分器
@Override
public void onEnable() {
game = GameLibrary.getLibrary().setMaxPlayerInOneTeam(1)
//设置 <SUF>
.teamNumber(2)
//设置队数量
.build()
//生成Game实例对象
.addEvent(EventType.PLAYING_PLAYER_DEATH, gameEvent -> {
GamePlayerDeathEvent event = (GamePlayerDeathEvent)gameEvent;
//这里可以强转
PlayingPlayer player = PlayingPlayer.search(event.getProp().getEntity().getKiller());
//获取PlayingPlayer实例对象
if (player.getGame() == null || player.getTeam() == -1) {
//检查一下杀人者是否在游戏当中
return;
}
manager.addOneScore(player.getTeam());
//加一分
game.broadcastMsg(ChatColor.RED+player.getPlayerName()+"杀死了"+event.getProp().getEntity().getName());
//广播杀敌信息
game.broadcastMsg(ChatColor.RED+"目前组"+event.getPlayer().getTeam()+"分数: "+manager.getScore(player.getTeam()));
//广播分数
})
.addEvent(EventType.ON_GAME_JOIN, gameEvent -> {
((Player)gameEvent.getPlayer()).sendMessage("你进入了游戏.");
//凡是以"ON"开头的事件都得转成Player，其他转成PlayingPlayer即可
})
.addEvent(EventType.ON_GAME_QUIT, gameEvent -> {
((Player)gameEvent.getPlayer()).sendMessage("你退出了游戏.");
//凡是以"ON"开头的事件都得转成Player，其他转成PlayingPlayer即可
})
.startGame(); //开始游戏
manager = new ScoreManager(game);
//实例化积分器对象
new CommandManager("tgame") //这是为了方便快速注册指令
.bindJoinCmd("join", this.game)
//快速加入游戏指令，不过不推荐这么做
.bindQuitCmd("quit", this.game);
//快速设置退出游戏指令
//注意: CommandManager仅在1.11.2以下版本奏效，若高于这个版本会报错。
//结果方案:自行注册指令
}
}
| false |
15431_7 | import java.util.ArrayList;
import java.util.Scanner;
import shuhelper.web.*;
public class TestWebAPI {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) throws Exception {
testCJWebAPI();
testXKWebAPI();
}
private static boolean login(WebAPI web) throws Exception {
// 获取验证码图片
String validatePath = web.getCaptcha();
System.out.println("验证码图片存储在: " + validatePath);
// 登录参数
System.out.print("学号: ");
String username = in.next();;
System.out.print("密码: ");
String password = in.next();;
System.out.print("验证码: ");
String validate = in.next();
// 尝试登录
String res = web.login(username, password, validate);
System.out.println("登录结果: " + res);
// 返回登录状态
return web.isLogin();
}
public static void testCJWebAPI() throws Exception {
// 实例化 CJWebAPI
CJWebAPI CJ = new CJWebAPI();
// 登录
if (!login(CJ)) return;
// 获取2016年冬季学期(20162)课程安排
ArrayList<String[]> schedule = CJ.getScheduleArrayList("20162");
output(schedule, "课程安排 - 2016冬");
// 获取2016年秋季学期(20161)学期成绩
ArrayList<String[]> scoreTerm = CJ.getScoreTermArrayList("20161");
output(scoreTerm, "学期成绩 - 2016秋");
// 获取成绩大表
ArrayList<String[]> scoreSummary = CJ.getScoreSummaryArrayList();
output(scoreSummary, "成绩大表");
}
public static void testXKWebAPI() throws Exception {
// 实例化 XKWebAPI
XKWebAPI XK = new XKWebAPI();
// 查看学期
String[] termInfo = XK.getTermInfo();
for (int i = 0; i < termInfo.length; i++) {
System.out.printf("[%d] %s\n", i, termInfo[i]);
}
// 选择
System.out.print("请选择学期编号: ");
int termNo = in.nextInt();
XK.setTerm(termNo);
// 登录
if (!login(XK)) return;
// 已选课程
ArrayList<String[]> courseTable = XK.getCourseTableArrayList();
output(courseTable, "已选课程");
// 选课排名
ArrayList<String[]> enrollRank = XK.getEnrollRankArrayList();
output(enrollRank, "选课排名");
// 查询所有"0830"课程
ArrayList<String[]> queryCourse = XK.getAllCourseArray("0830");
output(queryCourse, "0830课程");
// 查询选课系统状态
System.out.println("选课状态: " + XK.getEnrollStatus());
// 选课
System.out.println("选课结果: " + XK.enrollCourse("08305013", "1001"));
// 退课
System.out.println("退课结果: " + XK.returnCourse("08305013", "1001"));
}
private static void output(ArrayList<String[]> arrayList, String title) {
System.out.println("================================");
System.out.println(title);
System.out.println("================================");
for (String[] row : arrayList) {
for (String col : row)
System.out.print(col + "\t");
System.out.println();
}
System.out.printf("-------- Total %d row(s) --------\n", arrayList.size());
}
}
| Lodour/SHU-Helper | jar/TestWebAPI.java | 992 | // 获取成绩大表 | line_comment | zh-cn | import java.util.ArrayList;
import java.util.Scanner;
import shuhelper.web.*;
public class TestWebAPI {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) throws Exception {
testCJWebAPI();
testXKWebAPI();
}
private static boolean login(WebAPI web) throws Exception {
// 获取验证码图片
String validatePath = web.getCaptcha();
System.out.println("验证码图片存储在: " + validatePath);
// 登录参数
System.out.print("学号: ");
String username = in.next();;
System.out.print("密码: ");
String password = in.next();;
System.out.print("验证码: ");
String validate = in.next();
// 尝试登录
String res = web.login(username, password, validate);
System.out.println("登录结果: " + res);
// 返回登录状态
return web.isLogin();
}
public static void testCJWebAPI() throws Exception {
// 实例化 CJWebAPI
CJWebAPI CJ = new CJWebAPI();
// 登录
if (!login(CJ)) return;
// 获取2016年冬季学期(20162)课程安排
ArrayList<String[]> schedule = CJ.getScheduleArrayList("20162");
output(schedule, "课程安排 - 2016冬");
// 获取2016年秋季学期(20161)学期成绩
ArrayList<String[]> scoreTerm = CJ.getScoreTermArrayList("20161");
output(scoreTerm, "学期成绩 - 2016秋");
// 获取 <SUF>
ArrayList<String[]> scoreSummary = CJ.getScoreSummaryArrayList();
output(scoreSummary, "成绩大表");
}
public static void testXKWebAPI() throws Exception {
// 实例化 XKWebAPI
XKWebAPI XK = new XKWebAPI();
// 查看学期
String[] termInfo = XK.getTermInfo();
for (int i = 0; i < termInfo.length; i++) {
System.out.printf("[%d] %s\n", i, termInfo[i]);
}
// 选择
System.out.print("请选择学期编号: ");
int termNo = in.nextInt();
XK.setTerm(termNo);
// 登录
if (!login(XK)) return;
// 已选课程
ArrayList<String[]> courseTable = XK.getCourseTableArrayList();
output(courseTable, "已选课程");
// 选课排名
ArrayList<String[]> enrollRank = XK.getEnrollRankArrayList();
output(enrollRank, "选课排名");
// 查询所有"0830"课程
ArrayList<String[]> queryCourse = XK.getAllCourseArray("0830");
output(queryCourse, "0830课程");
// 查询选课系统状态
System.out.println("选课状态: " + XK.getEnrollStatus());
// 选课
System.out.println("选课结果: " + XK.enrollCourse("08305013", "1001"));
// 退课
System.out.println("退课结果: " + XK.returnCourse("08305013", "1001"));
}
private static void output(ArrayList<String[]> arrayList, String title) {
System.out.println("================================");
System.out.println(title);
System.out.println("================================");
for (String[] row : arrayList) {
for (String col : row)
System.out.print(col + "\t");
System.out.println();
}
System.out.printf("-------- Total %d row(s) --------\n", arrayList.size());
}
}
| false |
55584_3 | package com.house.shiro;
import com.house.dao.SysUserRoleDao;
import com.house.service.RedisService;
import com.house.utils.JwtTokenUtil;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/** 自定义域 CustomRealm
*
* Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户身份信息及用户权限数据，
* 比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息
*/
public class CustomRealm extends AuthorizingRealm {
@Autowired
private RedisService redisService;
@Autowired
private SysUserRoleDao sysUserRoleDao;
/**
* 此方法必须有，不然我们自定义的 CustomUsernamePasswordToken 不生效
* @param token
* @return
*/
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof CustomUsernamePasswordToken;
}
/**
* 用户授权，设置用户所拥有的 角色/权限
* @param principals
* @return
* @throws AuthenticationException
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String accessToken = (String) principals.getPrimaryPrincipal();
// 授权器
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
JwtTokenUtil instance = JwtTokenUtil.getInstance();
String userId = instance.getUserId(accessToken);
// 判断 redis 中是否缓存有权限信息
//if (redisService.hasKey(Constant.IDENTIFY_CACHE_KEY + userId)){
// redisService.get(Constant.IDENTIFY_CACHE_KEY + userId);
//}
// 通过用户id获取该用户所拥有的角色名称
List<String> roleNames = sysUserRoleDao.getRoleNameByUserId(userId);
if (roleNames != null && !roleNames.isEmpty()){
authorizationInfo.addRoles(roleNames);
}
// 通过用户id获取该用户所拥有的权限授权 如：sys:user:add
List<String> permissionPerms = sysUserRoleDao.getPermissionPermsByUserId(userId);
if (permissionPerms != null && !permissionPerms.isEmpty()){
authorizationInfo.addStringPermissions(permissionPerms);
}
return authorizationInfo;
}
/**
* 用户认证，以前是验证用户名/密码。现在我们验证 token，吧我们的 token 交还给 认证器
* @param token
* @return
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// 把我们的 token 交还给 认证器
CustomUsernamePasswordToken customUsernamePasswordToken = (CustomUsernamePasswordToken) token;
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(customUsernamePasswordToken.getPrincipal(), customUsernamePasswordToken.getCredentials(), CustomRealm.class.getName());
return info;
}
}
| Logistic98/house-price-monitor | admin/src/main/java/com/house/shiro/CustomRealm.java | 767 | // 授权器 | line_comment | zh-cn | package com.house.shiro;
import com.house.dao.SysUserRoleDao;
import com.house.service.RedisService;
import com.house.utils.JwtTokenUtil;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/** 自定义域 CustomRealm
*
* Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户身份信息及用户权限数据，
* 比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息
*/
public class CustomRealm extends AuthorizingRealm {
@Autowired
private RedisService redisService;
@Autowired
private SysUserRoleDao sysUserRoleDao;
/**
* 此方法必须有，不然我们自定义的 CustomUsernamePasswordToken 不生效
* @param token
* @return
*/
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof CustomUsernamePasswordToken;
}
/**
* 用户授权，设置用户所拥有的 角色/权限
* @param principals
* @return
* @throws AuthenticationException
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
String accessToken = (String) principals.getPrimaryPrincipal();
// 授权 <SUF>
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
JwtTokenUtil instance = JwtTokenUtil.getInstance();
String userId = instance.getUserId(accessToken);
// 判断 redis 中是否缓存有权限信息
//if (redisService.hasKey(Constant.IDENTIFY_CACHE_KEY + userId)){
// redisService.get(Constant.IDENTIFY_CACHE_KEY + userId);
//}
// 通过用户id获取该用户所拥有的角色名称
List<String> roleNames = sysUserRoleDao.getRoleNameByUserId(userId);
if (roleNames != null && !roleNames.isEmpty()){
authorizationInfo.addRoles(roleNames);
}
// 通过用户id获取该用户所拥有的权限授权 如：sys:user:add
List<String> permissionPerms = sysUserRoleDao.getPermissionPermsByUserId(userId);
if (permissionPerms != null && !permissionPerms.isEmpty()){
authorizationInfo.addStringPermissions(permissionPerms);
}
return authorizationInfo;
}
/**
* 用户认证，以前是验证用户名/密码。现在我们验证 token，吧我们的 token 交还给 认证器
* @param token
* @return
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// 把我们的 token 交还给 认证器
CustomUsernamePasswordToken customUsernamePasswordToken = (CustomUsernamePasswordToken) token;
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(customUsernamePasswordToken.getPrincipal(), customUsernamePasswordToken.getCredentials(), CustomRealm.class.getName());
return info;
}
}
| false |
19731_29 | package coursework.gui;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.KeyEvent;
import java.io.*;
import java.nio.charset.StandardCharsets;
/**
* @author Lolipop
* @version 1.0.1
* @lastUpdate 2019/11/6
*/
public class NoteBook {
private JTextArea textArea;
private File file = null;
private JFrame frame = new JFrame("NoteBook");
private Clipboard clipboard = frame.getToolkit().getSystemClipboard();
private NoteBook() {
// Frame
frame.setSize(600, 400);
frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
// TextArea
textArea = new JTextArea();
textArea.setFont(new Font("黑体", Font.PLAIN, 20));
// ScrollPane
JScrollPane pane = new JScrollPane(textArea);
frame.add(pane);
// Menu
// Menu: init menu body
JMenuBar menu = new JMenuBar();
frame.setJMenuBar(menu);
// Menu: create menus
JMenu fileMenu = new JMenu("File(F)");
JMenu editMenu = new JMenu("Edit(E)");
fileMenu.setMnemonic(KeyEvent.VK_F);
editMenu.setMnemonic(KeyEvent.VK_E);
// Menu: create menu items
JMenuItem newItem = new JMenuItem("New(N)", KeyEvent.VK_N);
JMenuItem openItem = new JMenuItem("Open(O)", KeyEvent.VK_O);
JMenuItem saveItem = new JMenuItem("Save(S)", KeyEvent.VK_S);
JMenuItem exitItem = new JMenuItem("Exit(X)", KeyEvent.VK_X);
JMenuItem cutItem = new JMenuItem("Cut(T)", KeyEvent.VK_T);
JMenuItem copyItem = new JMenuItem("Copy(C)", KeyEvent.VK_C);
JMenuItem pasteItem = new JMenuItem("Paste(P)", KeyEvent.VK_P);
// fileMenu: set events
// 新建NoteBook窗口
newItem.addActionListener(e -> new NoteBook());
// 打开文件
openItem.addActionListener(e -> {
JFileChooser fileChooser = new JFileChooser();
if (fileChooser.showOpenDialog(openItem) == JFileChooser.APPROVE_OPTION) {
File aimFile = fileChooser.getSelectedFile();
// 打开新窗口并读取文件
NoteBook newNoteBook = new NoteBook();
readFile(aimFile, newNoteBook.textArea);
}
});
// 保存文件
saveItem.addActionListener(e -> {
// 文件存在时（已经保存过）
if (file != null) {
saveFile(file.getPath());
}
// 文件不存在时（初次保存）
else {
JFileChooser fileChooser = new JFileChooser();
// 后缀名过滤
String extension = ".txt";
fileChooser.setFileFilter(new FileNameExtensionFilter("文本文件(*.txt)", extension));
if (fileChooser.showSaveDialog(saveItem) == JFileChooser.APPROVE_OPTION) {
File newFile = fileChooser.getSelectedFile();
// 获取用户输入的文件名
String fName = fileChooser.getName(newFile);
// 若文件名不包含".txt"后缀则在最后加上".txt"
if (!fName.contains(extension)) {
newFile = new File(fileChooser.getCurrentDirectory(), fName+".txt");
}
// 保存文件
saveFile(newFile.getPath());
// 修改全局变量file
file = newFile;
// 修改窗口title
frame.setTitle(file.getName()+" - NoteBook");
}
}
});
// 退出NoteBook
exitItem.addActionListener(e -> {
int choice = JOptionPane.showConfirmDialog(null, "Confirm exit NoteBook?",
"Exit", JOptionPane.YES_NO_OPTION);
if (choice == 0) {
frame.dispose();
}
});
// editMenu: set events
// 剪切
cutItem.addActionListener(e -> {
// 将选中的文本内容传递给剪切板
StringSelection cutText = new StringSelection(textArea.getSelectedText());
clipboard.setContents(cutText, null);
// 删除选中文本
int start = textArea.getSelectionStart();
int end = textArea.getSelectionEnd();
textArea.replaceRange("", start, end);
});
// 复制
copyItem.addActionListener(e -> {
StringSelection copyText = new StringSelection(textArea.getSelectedText());
clipboard.setContents(copyText, null);
});
// 粘贴
pasteItem.addActionListener(e -> {
// 从剪切板获取内容保存到contents中
Transferable contents = clipboard.getContents(null);
// 设置DataFlavor映射剪切板String型数据
DataFlavor flavor = DataFlavor.stringFlavor;
// 若存在String型数据，则将数据粘贴到光标选中处
if (contents.isDataFlavorSupported(flavor)) {
try {
// 将contents数据转化成String格式保存到text中
String text = (String)contents.getTransferData(flavor);
// 替换选中内容
int start = textArea.getSelectionStart();
int end = textArea.getSelectionEnd();
textArea.replaceRange(text, start, end);
} catch (UnsupportedFlavorException | IOException ex) {
ex.printStackTrace();
}
}
});
// Menu: add items to menus
fileMenu.add(newItem);
fileMenu.add(openItem);
fileMenu.add(saveItem);
fileMenu.add(exitItem);
editMenu.add(cutItem);
editMenu.add(copyItem);
editMenu.add(pasteItem);
// Menu: add menus to menu body & set visible
menu.add(fileMenu);
menu.add(editMenu);
menu.setVisible(true);
// 设置界面可见
frame.setVisible(true);
}
/**
* 读取文件并在新的窗口显示出来
* @param file 选择欲打开的文件
* @param textArea 新建窗口的textArea
*/
private void readFile (File file, JTextArea textArea) {
// init StringBuilder
StringBuilder sBuilder = new StringBuilder();
try {
// init BufferedReader & str
// 指定GB2312编码以显示文件的中文字符
BufferedReader bReader = new BufferedReader(new InputStreamReader(new FileInputStream(file),
"GB2312"));
String str;
// BufferedReader所读取数据不为空行时，把str存储的行内容传递给StringBuilder
while ((str = bReader.readLine()) != null) {
sBuilder.append(str).append('\n');
}
// 将StringBuilder存储的数据显示在textArea上
textArea.setText(sBuilder.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 将输入的内容保存为文本文件
* @param path 文件存储的路径
*/
private void saveFile (String path) {
FileOutputStream os;
try {
// init FileOutputStream
os = new FileOutputStream(path);
// 将textArea域的内容转化为UTF_8编码格式的文本字符对象，并写入对应路径下的文件中
os.write(textArea.getText().getBytes(StandardCharsets.UTF_8));
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main (String[] args) {
new NoteBook();
}
}
| LolipopJ/uestc-coursework-repo | java-Coursework/gui/NoteBook.java | 1,717 | // 替换选中内容 | line_comment | zh-cn | package coursework.gui;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.KeyEvent;
import java.io.*;
import java.nio.charset.StandardCharsets;
/**
* @author Lolipop
* @version 1.0.1
* @lastUpdate 2019/11/6
*/
public class NoteBook {
private JTextArea textArea;
private File file = null;
private JFrame frame = new JFrame("NoteBook");
private Clipboard clipboard = frame.getToolkit().getSystemClipboard();
private NoteBook() {
// Frame
frame.setSize(600, 400);
frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
// TextArea
textArea = new JTextArea();
textArea.setFont(new Font("黑体", Font.PLAIN, 20));
// ScrollPane
JScrollPane pane = new JScrollPane(textArea);
frame.add(pane);
// Menu
// Menu: init menu body
JMenuBar menu = new JMenuBar();
frame.setJMenuBar(menu);
// Menu: create menus
JMenu fileMenu = new JMenu("File(F)");
JMenu editMenu = new JMenu("Edit(E)");
fileMenu.setMnemonic(KeyEvent.VK_F);
editMenu.setMnemonic(KeyEvent.VK_E);
// Menu: create menu items
JMenuItem newItem = new JMenuItem("New(N)", KeyEvent.VK_N);
JMenuItem openItem = new JMenuItem("Open(O)", KeyEvent.VK_O);
JMenuItem saveItem = new JMenuItem("Save(S)", KeyEvent.VK_S);
JMenuItem exitItem = new JMenuItem("Exit(X)", KeyEvent.VK_X);
JMenuItem cutItem = new JMenuItem("Cut(T)", KeyEvent.VK_T);
JMenuItem copyItem = new JMenuItem("Copy(C)", KeyEvent.VK_C);
JMenuItem pasteItem = new JMenuItem("Paste(P)", KeyEvent.VK_P);
// fileMenu: set events
// 新建NoteBook窗口
newItem.addActionListener(e -> new NoteBook());
// 打开文件
openItem.addActionListener(e -> {
JFileChooser fileChooser = new JFileChooser();
if (fileChooser.showOpenDialog(openItem) == JFileChooser.APPROVE_OPTION) {
File aimFile = fileChooser.getSelectedFile();
// 打开新窗口并读取文件
NoteBook newNoteBook = new NoteBook();
readFile(aimFile, newNoteBook.textArea);
}
});
// 保存文件
saveItem.addActionListener(e -> {
// 文件存在时（已经保存过）
if (file != null) {
saveFile(file.getPath());
}
// 文件不存在时（初次保存）
else {
JFileChooser fileChooser = new JFileChooser();
// 后缀名过滤
String extension = ".txt";
fileChooser.setFileFilter(new FileNameExtensionFilter("文本文件(*.txt)", extension));
if (fileChooser.showSaveDialog(saveItem) == JFileChooser.APPROVE_OPTION) {
File newFile = fileChooser.getSelectedFile();
// 获取用户输入的文件名
String fName = fileChooser.getName(newFile);
// 若文件名不包含".txt"后缀则在最后加上".txt"
if (!fName.contains(extension)) {
newFile = new File(fileChooser.getCurrentDirectory(), fName+".txt");
}
// 保存文件
saveFile(newFile.getPath());
// 修改全局变量file
file = newFile;
// 修改窗口title
frame.setTitle(file.getName()+" - NoteBook");
}
}
});
// 退出NoteBook
exitItem.addActionListener(e -> {
int choice = JOptionPane.showConfirmDialog(null, "Confirm exit NoteBook?",
"Exit", JOptionPane.YES_NO_OPTION);
if (choice == 0) {
frame.dispose();
}
});
// editMenu: set events
// 剪切
cutItem.addActionListener(e -> {
// 将选中的文本内容传递给剪切板
StringSelection cutText = new StringSelection(textArea.getSelectedText());
clipboard.setContents(cutText, null);
// 删除选中文本
int start = textArea.getSelectionStart();
int end = textArea.getSelectionEnd();
textArea.replaceRange("", start, end);
});
// 复制
copyItem.addActionListener(e -> {
StringSelection copyText = new StringSelection(textArea.getSelectedText());
clipboard.setContents(copyText, null);
});
// 粘贴
pasteItem.addActionListener(e -> {
// 从剪切板获取内容保存到contents中
Transferable contents = clipboard.getContents(null);
// 设置DataFlavor映射剪切板String型数据
DataFlavor flavor = DataFlavor.stringFlavor;
// 若存在String型数据，则将数据粘贴到光标选中处
if (contents.isDataFlavorSupported(flavor)) {
try {
// 将contents数据转化成String格式保存到text中
String text = (String)contents.getTransferData(flavor);
// 替换 <SUF>
int start = textArea.getSelectionStart();
int end = textArea.getSelectionEnd();
textArea.replaceRange(text, start, end);
} catch (UnsupportedFlavorException | IOException ex) {
ex.printStackTrace();
}
}
});
// Menu: add items to menus
fileMenu.add(newItem);
fileMenu.add(openItem);
fileMenu.add(saveItem);
fileMenu.add(exitItem);
editMenu.add(cutItem);
editMenu.add(copyItem);
editMenu.add(pasteItem);
// Menu: add menus to menu body & set visible
menu.add(fileMenu);
menu.add(editMenu);
menu.setVisible(true);
// 设置界面可见
frame.setVisible(true);
}
/**
* 读取文件并在新的窗口显示出来
* @param file 选择欲打开的文件
* @param textArea 新建窗口的textArea
*/
private void readFile (File file, JTextArea textArea) {
// init StringBuilder
StringBuilder sBuilder = new StringBuilder();
try {
// init BufferedReader & str
// 指定GB2312编码以显示文件的中文字符
BufferedReader bReader = new BufferedReader(new InputStreamReader(new FileInputStream(file),
"GB2312"));
String str;
// BufferedReader所读取数据不为空行时，把str存储的行内容传递给StringBuilder
while ((str = bReader.readLine()) != null) {
sBuilder.append(str).append('\n');
}
// 将StringBuilder存储的数据显示在textArea上
textArea.setText(sBuilder.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 将输入的内容保存为文本文件
* @param path 文件存储的路径
*/
private void saveFile (String path) {
FileOutputStream os;
try {
// init FileOutputStream
os = new FileOutputStream(path);
// 将textArea域的内容转化为UTF_8编码格式的文本字符对象，并写入对应路径下的文件中
os.write(textArea.getText().getBytes(StandardCharsets.UTF_8));
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main (String[] args) {
new NoteBook();
}
}
| false |
61368_2 | package com.smallfatcat.thread.thread3;
/**
* @author zsz
* @Description
* @date 2022/9/2
*/
public class Culprit {
public synchronized void say(Police p){ //加锁方法
System.out.println("罪犯：你放了我，我就放了人质");
p.fun(); //调用警察方法
}
public synchronized void fun(){ //加锁方法
System.out.println("我放了人质，警察也放了我");
}
}
| LongTimeNC/Thread | src/main/java/com/smallfatcat/thread/thread3/Culprit.java | 137 | //调用警察方法 | line_comment | zh-cn | package com.smallfatcat.thread.thread3;
/**
* @author zsz
* @Description
* @date 2022/9/2
*/
public class Culprit {
public synchronized void say(Police p){ //加锁方法
System.out.println("罪犯：你放了我，我就放了人质");
p.fun(); //调用 <SUF>
}
public synchronized void fun(){ //加锁方法
System.out.println("我放了人质，警察也放了我");
}
}
| false |
62363_7 | package cn.lyl.entity;
import java.util.HashSet;
import java.util.Set;
public class KeShi {
private Integer KSBH;//课室编号
private String KSMC;//课室名称
private Integer KSHS;//课室行数
private Integer KSLS;//课室列数
private Integer KSGDS;//课室过道数
private Integer KSZS;//课室最适人数
private String KSGDL;//课室过道所在列，中间用##分开
private String KSKZ1;//扩展字段1
private Integer KSKZ2;//扩展字段2
private Integer KSKZ3;//扩展字段3
private Integer KSKZ4;//扩展字段4
private String KSKZ5;//扩展字段5
//在课室里面表示所属楼栋，一个课室只能属于一个楼栋
private LouDong loudong;//
//在课室里面表示所拥有的课室，一个课室可以拥有多个座位
private Set<ZuoWei> setzuowei = new HashSet<ZuoWei>();
public Integer getKSBH() {
return KSBH;
}
public void setKSBH(Integer kSBH) {
KSBH = kSBH;
}
public String getKSMC() {
return KSMC;
}
public void setKSMC(String kSMC) {
KSMC = kSMC;
}
public Integer getKSHS() {
return KSHS;
}
public void setKSHS(Integer kSHS) {
KSHS = kSHS;
}
public Integer getKSLS() {
return KSLS;
}
public void setKSLS(Integer kSLS) {
KSLS = kSLS;
}
public Integer getKSGDS() {
return KSGDS;
}
public void setKSGDS(Integer kSGDS) {
KSGDS = kSGDS;
}
public Integer getKSZS() {
return KSZS;
}
public void setKSZS(Integer kSZS) {
KSZS = kSZS;
}
public String getKSGDL() {
return KSGDL;
}
public void setKSGDL(String kSGDL) {
KSGDL = kSGDL;
}
public String getKSKZ1() {
return KSKZ1;
}
public void setKSKZ1(String kSKZ1) {
KSKZ1 = kSKZ1;
}
public Integer getKSKZ2() {
return KSKZ2;
}
public void setKSKZ2(Integer kSKZ2) {
KSKZ2 = kSKZ2;
}
public Integer getKSKZ3() {
return KSKZ3;
}
public void setKSKZ3(Integer kSKZ3) {
KSKZ3 = kSKZ3;
}
public Integer getKSKZ4() {
return KSKZ4;
}
public void setKSKZ4(Integer kSKZ4) {
KSKZ4 = kSKZ4;
}
public String getKSKZ5() {
return KSKZ5;
}
public void setKSKZ5(String kSKZ5) {
KSKZ5 = kSKZ5;
}
public LouDong getLoudong() {
return loudong;
}
public void setLoudong(LouDong loudong) {
this.loudong = loudong;
}
public Set<ZuoWei> getSetzuowei() {
return setzuowei;
}
public void setSetzuowei(Set<ZuoWei> setzuowei) {
this.setzuowei = setzuowei;
}
}
| LongYil/SeatArrangement | src/main/java/cn/lyl/entity/KeShi.java | 986 | //扩展字段1 | line_comment | zh-cn | package cn.lyl.entity;
import java.util.HashSet;
import java.util.Set;
public class KeShi {
private Integer KSBH;//课室编号
private String KSMC;//课室名称
private Integer KSHS;//课室行数
private Integer KSLS;//课室列数
private Integer KSGDS;//课室过道数
private Integer KSZS;//课室最适人数
private String KSGDL;//课室过道所在列，中间用##分开
private String KSKZ1;//扩展 <SUF>
private Integer KSKZ2;//扩展字段2
private Integer KSKZ3;//扩展字段3
private Integer KSKZ4;//扩展字段4
private String KSKZ5;//扩展字段5
//在课室里面表示所属楼栋，一个课室只能属于一个楼栋
private LouDong loudong;//
//在课室里面表示所拥有的课室，一个课室可以拥有多个座位
private Set<ZuoWei> setzuowei = new HashSet<ZuoWei>();
public Integer getKSBH() {
return KSBH;
}
public void setKSBH(Integer kSBH) {
KSBH = kSBH;
}
public String getKSMC() {
return KSMC;
}
public void setKSMC(String kSMC) {
KSMC = kSMC;
}
public Integer getKSHS() {
return KSHS;
}
public void setKSHS(Integer kSHS) {
KSHS = kSHS;
}
public Integer getKSLS() {
return KSLS;
}
public void setKSLS(Integer kSLS) {
KSLS = kSLS;
}
public Integer getKSGDS() {
return KSGDS;
}
public void setKSGDS(Integer kSGDS) {
KSGDS = kSGDS;
}
public Integer getKSZS() {
return KSZS;
}
public void setKSZS(Integer kSZS) {
KSZS = kSZS;
}
public String getKSGDL() {
return KSGDL;
}
public void setKSGDL(String kSGDL) {
KSGDL = kSGDL;
}
public String getKSKZ1() {
return KSKZ1;
}
public void setKSKZ1(String kSKZ1) {
KSKZ1 = kSKZ1;
}
public Integer getKSKZ2() {
return KSKZ2;
}
public void setKSKZ2(Integer kSKZ2) {
KSKZ2 = kSKZ2;
}
public Integer getKSKZ3() {
return KSKZ3;
}
public void setKSKZ3(Integer kSKZ3) {
KSKZ3 = kSKZ3;
}
public Integer getKSKZ4() {
return KSKZ4;
}
public void setKSKZ4(Integer kSKZ4) {
KSKZ4 = kSKZ4;
}
public String getKSKZ5() {
return KSKZ5;
}
public void setKSKZ5(String kSKZ5) {
KSKZ5 = kSKZ5;
}
public LouDong getLoudong() {
return loudong;
}
public void setLoudong(LouDong loudong) {
this.loudong = loudong;
}
public Set<ZuoWei> getSetzuowei() {
return setzuowei;
}
public void setSetzuowei(Set<ZuoWei> setzuowei) {
this.setzuowei = setzuowei;
}
}
| false |
16036_24 | package com.easy.javacv;
import org.bytedeco.javacpp.avcodec;
import org.bytedeco.javacv.CanvasFrame;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.OpenCVFrameGrabber;
import javax.sound.sampled.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* <pre>
*前面我用了很多章实现了javaCV的基本操作，包括：音视频捕捉（摄像头视频捕捉和话筒音频捕捉），推流(本地音视频或者摄像头话筒混合推流到服务器)，转流（rtsp->rtmp），收流（录制）。
*
* 序：
* 我们知道javaCV中编码需要先取到一帧采样的音频（即采样率x通道数,我们姑且把这个称为一帧采样数据）
*
* 其实我们在该篇文章http://blog.csdn.net/eguid_1/article/details/52804246中已经对音频进行转码了。
*
* 额。。这个真没看出来（PS:博主也没看出来 0_0 !）。。。。。。。。。
*
* 我们获取了本地的音频音频数据（具体啥编码博主也不晓得，只知道是16位的， - -！ ，不过这不要紧，FFMPEG能我们实现，下面将会讲到 ）；
*
* 其中我们做了大小端序的转换和byte[]转short[]（双8位转单16位），音频编解码中这个操作我们会经常用；
*
* 然后我们使用了recoder.reacordSimples(采样率，通道数，一份采样);
*
* 对比一下音频捕获的文章：http://blog.csdn.net/eguid_1/article/details/52702385
*
* 发现了吗？没错，我们给recorder设置了一些属性：
*
*
*
* // 不可变(固定)音频比特率
* recorder.setAudioOption("crf", "0");
* // 最高质量
* recorder.setAudioQuality(0);
* // 音频比特率
* recorder.setAudioBitrate(192000);
* // 音频采样率
* recorder.setSampleRate(44100);
* // 双通道(立体声)
* recorder.setAudioChannels(2);
* // 音频编/解码器
* recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
* 看到了吗？我们其实已经设置了编/解码格式aac，为什么呢？因为javaCV已经封装了解复用和编码这两个操作。
*
*
*
* 补充：
* 补充一下javaCV底层的ffmpeg解复用/编码流程：
*
* 我们在进行recoder.reacordSimples的时候javaCV底层调用ffmpeg的swr_convert()方法(详见javaCV的FFmpegFrameRecoder类974行)进行了解码操作，完成了对pcm16le编码的解复用；
*
* 解码完成之后又调用了recorder.record(Frame frame)（详见javaCV的FFmpegFrameRecoder类994行），在这个环节完成了调用了FFMPEG的avcodec_encode_audio2()方法（详见javaCV的FFmpegFrameRecoder类1006行）按照我们已经设定好的的aac格式完成了编
*
* 码操作，所以我们本身是不需要进行解复用/编码的操作的（视频也是一样，以后会讲到），因为javaCV已经帮我门做了！
*
* 到这里肯定有些小伙伴已经5脸懵bi的状态了。。。 - -！，最不幸的是，上面一堆的前言和补充知识，我们的主题还没开始。 0_0 !
*
* eguid唯一技术博客是csdn，博主唯一交流群是群号:371249677 （点击这里进群），欢迎大家来埋汰群主
*
* 1、java音频预处理
* 既然javaCV已经帮我门做了解复用和编码，那么我们只需要将获得到的音频数据进行简单的预处理即可。
*
* 注：如果是文件或者服务器直播流，那么连预处理都省了，直接设置编码格式即可，不需要我们手动做任何处理。
*
*
*
* 这里讲一下特殊的byte[]流，也就是基于socket的IO流形式的音频数据处理，一般我们使用这种的情况是移动端通过socket推流到中转服务器，让中转服务器进行转码推送到流媒体服务器。
*
* 1.1、如何从byte[]流中获取一份完整的音频帧（即一帧采样数据）
* 就拿 8000采样率，16bit，双通道（立体声）的pcm16le编码来说吧举例说明吧
*
* 我们知道这个音频采样率是8000，位数是16bit，2个通道，那么我们就知道这个编码的一帧就是（8000x2 ）个byte
*
* 1.2、音频原始数据转换
* 一个byte只能表示8bit数据，我们要表示16位的音频数据就需要装换为short，一个short等于2个byte，在转换的同时进行大小端序转换（大小端序问题详见http://blog.csdn.net/eguid_1/article/details/52790848），那么我们最后得到的数据应该是一个长度是8000的short数组（即short[8000]）来表示一帧音频采样数据。
*
* 音频的预处理到此完毕，接下来该javaCV出场了
*
* 2、javaCV音频解复用及编码
* 通过上面一大堆的前言，已经知道：音频数据直接通过recorder设置音频编码参数即可自动进行解复用和编码
*
* 只需要调用recorder.recordSamples(采样率，通道数量，一份采样数据)即可。
*
* 我的天呐，这真真是用一行代码解决了C/C++好几百行的事情！
*
* 支持eguid原创
* ---------------------
* 作者： eguid
* 来源：CSDN
* 原文：https://blog.csdn.net/eguid_1/article/details/52875793
* 版权声明：本文为博主原创文章，转载请附上博文链接！
* javaCV开发详解之6：本地音频(话筒设备)和视频(摄像头)抓取、混合并推送(录制)到服务器(本地)
*
*
* javaCV开发详解之6：本地音频(话筒设备)和视频(摄像头)抓取、混合并推送(录制)到服务器(本地)
* 1、实现功能
* (1)抓取本地录音设备（即,话筒）的实时音频
*
* (2)抓取本地摄像头实时视频
*
* (3)音频与视频时两个线程分别进行的，互不干扰
*
* (4)多8bit的音频转小字节序问题，请参考http://blog.csdn.net/eguid_1/article/details/52790848
*
* (5)本章代码包含大量注释，用来阐述每个API的用法和作用
* ---------------------
* 作者： eguid
* 来源：CSDN
* 原文：https://blog.csdn.net/eguid_1/article/details/52804246
* 版权声明：本文为博主原创文章，转载请附上博文链接！
* </pre>
*/
public class JavaCV6RecordLocal {
/**
* 推送/录制本机的音/视频(Webcam/Microphone)到流媒体服务器(Stream media server)
*
* @param WEBCAM_DEVICE_INDEX
* - 视频设备，本机默认是0
* @param AUDIO_DEVICE_INDEX
* - 音频设备，本机默认是4
* @param outputFile
* - 输出文件/地址(可以是本地文件，也可以是流媒体服务器地址)
* @param captureWidth
* - 摄像头宽
* @param captureHeight
* - 摄像头高
* @param FRAME_RATE
* - 视频帧率:最低 25(即每秒25张图片,低于25就会出现闪屏)
* @throws org.bytedeco.javacv.FrameGrabber.Exception
*/
public static void recordWebcamAndMicrophone(int WEBCAM_DEVICE_INDEX, int AUDIO_DEVICE_INDEX, String outputFile,
int captureWidth, int captureHeight, int FRAME_RATE) throws org.bytedeco.javacv.FrameGrabber.Exception {
long startTime = 0;
long videoTS = 0;
/**
* FrameGrabber 类包含：OpenCVFrameGrabber
* (opencv_videoio),C1394FrameGrabber, FlyCaptureFrameGrabber,
* OpenKinectFrameGrabber,PS3EyeFrameGrabber,VideoInputFrameGrabber, 和
* FFmpegFrameGrabber.
*/
OpenCVFrameGrabber grabber = new OpenCVFrameGrabber(WEBCAM_DEVICE_INDEX);
grabber.setImageWidth(captureWidth);
grabber.setImageHeight(captureHeight);
System.out.println("开始抓取摄像头...");
int isTrue = 0;// 摄像头开启状态
try {
grabber.start();
isTrue += 1;
} catch (org.bytedeco.javacv.FrameGrabber.Exception e2) {
if (grabber != null) {
try {
grabber.restart();
isTrue += 1;
} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
isTrue -= 1;
try {
grabber.stop();
} catch (org.bytedeco.javacv.FrameGrabber.Exception e1) {
isTrue -= 1;
}
}
}
}
if (isTrue < 0) {
System.err.println("摄像头首次开启失败，尝试重启也失败！");
return;
} else if (isTrue < 1) {
System.err.println("摄像头开启失败！");
return;
} else if (isTrue == 1) {
System.err.println("摄像头开启成功！");
} else if (isTrue == 1) {
System.err.println("摄像头首次开启失败，重新启动成功！");
}
/**
* FFmpegFrameRecorder(String filename, int imageWidth, int imageHeight,
* int audioChannels) fileName可以是本地文件（会自动创建），也可以是RTMP路径（发布到流媒体服务器）
* imageWidth = width （为捕获器设置宽） imageHeight = height （为捕获器设置高）
* audioChannels = 2（立体声）；1（单声道）；0（无音频）
*/
FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(outputFile, captureWidth, captureHeight, 2);
recorder.setInterleaved(true);
/**
* 该参数用于降低延迟 参考FFMPEG官方文档：https://trac.ffmpeg.org/wiki/StreamingGuide
* 官方原文参考：ffmpeg -f dshow -i video="Virtual-Camera" -vcodec libx264
* -tune zerolatency -b 900k -f mpegts udp://10.1.0.102:1234
*/
recorder.setVideoOption("tune", "zerolatency");
/**
* 权衡quality(视频质量)和encode speed(编码速度) values(值)：
* ultrafast(终极快),superfast(超级快), veryfast(非常快), faster(很快), fast(快),
* medium(中等), slow(慢), slower(很慢), veryslow(非常慢)
* ultrafast(终极快)提供最少的压缩（低编码器CPU）和最大的视频流大小；而veryslow(非常慢)提供最佳的压缩（高编码器CPU）的同时降低视频流的大小
* 参考：https://trac.ffmpeg.org/wiki/Encode/H.264 官方原文参考：-preset ultrafast
* as the name implies provides for the fastest possible encoding. If
* some tradeoff between quality and encode speed, go for the speed.
* This might be needed if you are going to be transcoding multiple
* streams on one machine.
*/
recorder.setVideoOption("preset", "ultrafast");
/**
* 参考转流命令: ffmpeg
* -i'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1' -crf 30
* -preset ultrafast -acodec aac -strict experimental -ar 44100 -ac
* 2-b:a 96k -vcodec libx264 -r 25 -b:v 500k -f flv 'rtmp://<wowza
* serverIP>/live/cam0' -crf 30
* -设置内容速率因子,这是一个x264的动态比特率参数，它能够在复杂场景下(使用不同比特率，即可变比特率)保持视频质量；
* 可以设置更低的质量(quality)和比特率(bit rate),参考Encode/H.264 -preset ultrafast
* -参考上面preset参数，与视频压缩率(视频大小)和速度有关,需要根据情况平衡两大点：压缩率(视频大小)，编/解码速度 -acodec
* aac -设置音频编/解码器 (内部AAC编码) -strict experimental
* -允许使用一些实验的编解码器(比如上面的内部AAC属于实验编解码器) -ar 44100 设置音频采样率(audio sample
* rate) -ac 2 指定双通道音频(即立体声) -b:a 96k 设置音频比特率(bit rate) -vcodec libx264
* 设置视频编解码器(codec) -r 25 -设置帧率(frame rate) -b:v 500k -设置视频比特率(bit
* rate),比特率越高视频越清晰,视频体积也会变大,需要根据实际选择合理范围 -f flv
* -提供输出流封装格式(rtmp协议只支持flv封装格式) 'rtmp://<FMS server
* IP>/live/cam0'-流媒体服务器地址
*/
recorder.setVideoOption("crf", "25");
// 2000 kb/s, 720P视频的合理比特率范围
recorder.setVideoBitrate(2000000);
// h264编/解码器
recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
// 封装格式flv
recorder.setFormat("flv");
// 视频帧率(保证视频质量的情况下最低25，低于25会出现闪屏)
recorder.setFrameRate(FRAME_RATE);
// 关键帧间隔，一般与帧率相同或者是视频帧率的两倍
recorder.setGopSize(FRAME_RATE * 2);
// 不可变(固定)音频比特率
recorder.setAudioOption("crf", "0");
// 最高质量
recorder.setAudioQuality(0);
// 音频比特率
recorder.setAudioBitrate(192000);
// 音频采样率
recorder.setSampleRate(44100);
// 双通道(立体声)
recorder.setAudioChannels(2);
// 音频编/解码器
recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
System.out.println("开始录制...");
try {
recorder.start();
} catch (org.bytedeco.javacv.FrameRecorder.Exception e2) {
if (recorder != null) {
System.out.println("关闭失败，尝试重启");
try {
recorder.stop();
recorder.start();
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
try {
System.out.println("开启失败，关闭录制");
recorder.stop();
return;
} catch (org.bytedeco.javacv.FrameRecorder.Exception e1) {
return;
}
}
}
}
// 音频捕获
new Thread(new Runnable() {
@Override
public void run() {
/**
* 设置音频编码器 最好是系统支持的格式，否则getLine() 会发生错误
* 采样率:44.1k;采样率位数:16位;立体声(stereo);是否签名;true:
* big-endian字节顺序,false:little-endian字节顺序(详见:ByteOrder类)
*/
AudioFormat audioFormat = new AudioFormat(44100.0F, 16, 2, true, false);
// 通过AudioSystem获取本地音频混合器信息
Mixer.Info[] minfoSet = AudioSystem.getMixerInfo();
// 通过AudioSystem获取本地音频混合器
Mixer mixer = AudioSystem.getMixer(minfoSet[AUDIO_DEVICE_INDEX]);
// 通过设置好的音频编解码器获取数据线信息
DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, audioFormat);
try {
// 打开并开始捕获音频
// 通过line可以获得更多控制权
// 获取设备：TargetDataLine line
// =(TargetDataLine)mixer.getLine(dataLineInfo);
TargetDataLine line = (TargetDataLine) AudioSystem.getLine(dataLineInfo);
line.open(audioFormat);
line.start();
// 获得当前音频采样率
int sampleRate = (int) audioFormat.getSampleRate();
// 获取当前音频通道数量
int numChannels = audioFormat.getChannels();
// 初始化音频缓冲区(size是音频采样率*通道数)
int audioBufferSize = sampleRate * numChannels;
byte[] audioBytes = new byte[audioBufferSize];
ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
exec.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
// 非阻塞方式读取
int nBytesRead = line.read(audioBytes, 0, line.available());
// 因为我们设置的是16位音频格式,所以需要将byte[]转成short[]
int nSamplesRead = nBytesRead / 2;
short[] samples = new short[nSamplesRead];
/**
* ByteBuffer.wrap(audioBytes)-将byte[]数组包装到缓冲区
* ByteBuffer.order(ByteOrder)-按little-endian修改字节顺序，解码器定义的
* ByteBuffer.asShortBuffer()-创建一个新的short[]缓冲区
* ShortBuffer.get(samples)-将缓冲区里short数据传输到short[]
*/
ByteBuffer.wrap(audioBytes).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(samples);
// 将short[]包装到ShortBuffer
ShortBuffer sBuff = ShortBuffer.wrap(samples, 0, nSamplesRead);
// 按通道录制shortBuffer
recorder.recordSamples(sampleRate, numChannels, sBuff);
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
e.printStackTrace();
}
}
}, 0, (long) 1000 / FRAME_RATE, TimeUnit.MILLISECONDS);
} catch (LineUnavailableException e1) {
e1.printStackTrace();
}
}
}).start();
// javaCV提供了优化非常好的硬件加速组件来帮助显示我们抓取的摄像头视频
CanvasFrame cFrame = new CanvasFrame("Capture Preview", CanvasFrame.getDefaultGamma() / grabber.getGamma());
Frame capturedFrame = null;
// 执行抓取（capture）过程
while ((capturedFrame = grabber.grab()) != null) {
if (cFrame.isVisible()) {
//本机预览要发送的帧
cFrame.showImage(capturedFrame);
}
//定义我们的开始时间，当开始时需要先初始化时间戳
if (startTime == 0)
startTime = System.currentTimeMillis();
// 创建一个 timestamp用来写入帧中
videoTS = 1000 * (System.currentTimeMillis() - startTime);
//检查偏移量
if (videoTS > recorder.getTimestamp()) {
System.out.println("Lip-flap correction: " + videoTS + " : " + recorder.getTimestamp() + " -> "
+ (videoTS - recorder.getTimestamp()));
//告诉录制器写入这个timestamp
recorder.setTimestamp(videoTS);
}
// 发送帧
try {
recorder.record(capturedFrame);
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
System.out.println("录制帧发生异常，什么都不做");
}
}
cFrame.dispose();
try {
if (recorder != null) {
recorder.stop();
}
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
System.out.println("关闭录制器失败");
try {
if (recorder != null) {
grabber.stop();
}
} catch (org.bytedeco.javacv.FrameGrabber.Exception e1) {
System.out.println("关闭摄像头失败");
return;
}
}
try {
if (recorder != null) {
grabber.stop();
}
} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
System.out.println("关闭摄像头失败");
}
}
public static void main(String[] args)
throws Exception {
recordWebcamAndMicrophone(0,4,"E://tmp/aa.flv",700,800,25);
}
}
| LonggangBai/ffmpeg-javacv | src/main/java/com.easy/javacv/JavaCV6RecordLocal.java | 5,472 | // 打开并开始捕获音频 | line_comment | zh-cn | package com.easy.javacv;
import org.bytedeco.javacpp.avcodec;
import org.bytedeco.javacv.CanvasFrame;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.OpenCVFrameGrabber;
import javax.sound.sampled.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* <pre>
*前面我用了很多章实现了javaCV的基本操作，包括：音视频捕捉（摄像头视频捕捉和话筒音频捕捉），推流(本地音视频或者摄像头话筒混合推流到服务器)，转流（rtsp->rtmp），收流（录制）。
*
* 序：
* 我们知道javaCV中编码需要先取到一帧采样的音频（即采样率x通道数,我们姑且把这个称为一帧采样数据）
*
* 其实我们在该篇文章http://blog.csdn.net/eguid_1/article/details/52804246中已经对音频进行转码了。
*
* 额。。这个真没看出来（PS:博主也没看出来 0_0 !）。。。。。。。。。
*
* 我们获取了本地的音频音频数据（具体啥编码博主也不晓得，只知道是16位的， - -！ ，不过这不要紧，FFMPEG能我们实现，下面将会讲到 ）；
*
* 其中我们做了大小端序的转换和byte[]转short[]（双8位转单16位），音频编解码中这个操作我们会经常用；
*
* 然后我们使用了recoder.reacordSimples(采样率，通道数，一份采样);
*
* 对比一下音频捕获的文章：http://blog.csdn.net/eguid_1/article/details/52702385
*
* 发现了吗？没错，我们给recorder设置了一些属性：
*
*
*
* // 不可变(固定)音频比特率
* recorder.setAudioOption("crf", "0");
* // 最高质量
* recorder.setAudioQuality(0);
* // 音频比特率
* recorder.setAudioBitrate(192000);
* // 音频采样率
* recorder.setSampleRate(44100);
* // 双通道(立体声)
* recorder.setAudioChannels(2);
* // 音频编/解码器
* recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
* 看到了吗？我们其实已经设置了编/解码格式aac，为什么呢？因为javaCV已经封装了解复用和编码这两个操作。
*
*
*
* 补充：
* 补充一下javaCV底层的ffmpeg解复用/编码流程：
*
* 我们在进行recoder.reacordSimples的时候javaCV底层调用ffmpeg的swr_convert()方法(详见javaCV的FFmpegFrameRecoder类974行)进行了解码操作，完成了对pcm16le编码的解复用；
*
* 解码完成之后又调用了recorder.record(Frame frame)（详见javaCV的FFmpegFrameRecoder类994行），在这个环节完成了调用了FFMPEG的avcodec_encode_audio2()方法（详见javaCV的FFmpegFrameRecoder类1006行）按照我们已经设定好的的aac格式完成了编
*
* 码操作，所以我们本身是不需要进行解复用/编码的操作的（视频也是一样，以后会讲到），因为javaCV已经帮我门做了！
*
* 到这里肯定有些小伙伴已经5脸懵bi的状态了。。。 - -！，最不幸的是，上面一堆的前言和补充知识，我们的主题还没开始。 0_0 !
*
* eguid唯一技术博客是csdn，博主唯一交流群是群号:371249677 （点击这里进群），欢迎大家来埋汰群主
*
* 1、java音频预处理
* 既然javaCV已经帮我门做了解复用和编码，那么我们只需要将获得到的音频数据进行简单的预处理即可。
*
* 注：如果是文件或者服务器直播流，那么连预处理都省了，直接设置编码格式即可，不需要我们手动做任何处理。
*
*
*
* 这里讲一下特殊的byte[]流，也就是基于socket的IO流形式的音频数据处理，一般我们使用这种的情况是移动端通过socket推流到中转服务器，让中转服务器进行转码推送到流媒体服务器。
*
* 1.1、如何从byte[]流中获取一份完整的音频帧（即一帧采样数据）
* 就拿 8000采样率，16bit，双通道（立体声）的pcm16le编码来说吧举例说明吧
*
* 我们知道这个音频采样率是8000，位数是16bit，2个通道，那么我们就知道这个编码的一帧就是（8000x2 ）个byte
*
* 1.2、音频原始数据转换
* 一个byte只能表示8bit数据，我们要表示16位的音频数据就需要装换为short，一个short等于2个byte，在转换的同时进行大小端序转换（大小端序问题详见http://blog.csdn.net/eguid_1/article/details/52790848），那么我们最后得到的数据应该是一个长度是8000的short数组（即short[8000]）来表示一帧音频采样数据。
*
* 音频的预处理到此完毕，接下来该javaCV出场了
*
* 2、javaCV音频解复用及编码
* 通过上面一大堆的前言，已经知道：音频数据直接通过recorder设置音频编码参数即可自动进行解复用和编码
*
* 只需要调用recorder.recordSamples(采样率，通道数量，一份采样数据)即可。
*
* 我的天呐，这真真是用一行代码解决了C/C++好几百行的事情！
*
* 支持eguid原创
* ---------------------
* 作者： eguid
* 来源：CSDN
* 原文：https://blog.csdn.net/eguid_1/article/details/52875793
* 版权声明：本文为博主原创文章，转载请附上博文链接！
* javaCV开发详解之6：本地音频(话筒设备)和视频(摄像头)抓取、混合并推送(录制)到服务器(本地)
*
*
* javaCV开发详解之6：本地音频(话筒设备)和视频(摄像头)抓取、混合并推送(录制)到服务器(本地)
* 1、实现功能
* (1)抓取本地录音设备（即,话筒）的实时音频
*
* (2)抓取本地摄像头实时视频
*
* (3)音频与视频时两个线程分别进行的，互不干扰
*
* (4)多8bit的音频转小字节序问题，请参考http://blog.csdn.net/eguid_1/article/details/52790848
*
* (5)本章代码包含大量注释，用来阐述每个API的用法和作用
* ---------------------
* 作者： eguid
* 来源：CSDN
* 原文：https://blog.csdn.net/eguid_1/article/details/52804246
* 版权声明：本文为博主原创文章，转载请附上博文链接！
* </pre>
*/
public class JavaCV6RecordLocal {
/**
* 推送/录制本机的音/视频(Webcam/Microphone)到流媒体服务器(Stream media server)
*
* @param WEBCAM_DEVICE_INDEX
* - 视频设备，本机默认是0
* @param AUDIO_DEVICE_INDEX
* - 音频设备，本机默认是4
* @param outputFile
* - 输出文件/地址(可以是本地文件，也可以是流媒体服务器地址)
* @param captureWidth
* - 摄像头宽
* @param captureHeight
* - 摄像头高
* @param FRAME_RATE
* - 视频帧率:最低 25(即每秒25张图片,低于25就会出现闪屏)
* @throws org.bytedeco.javacv.FrameGrabber.Exception
*/
public static void recordWebcamAndMicrophone(int WEBCAM_DEVICE_INDEX, int AUDIO_DEVICE_INDEX, String outputFile,
int captureWidth, int captureHeight, int FRAME_RATE) throws org.bytedeco.javacv.FrameGrabber.Exception {
long startTime = 0;
long videoTS = 0;
/**
* FrameGrabber 类包含：OpenCVFrameGrabber
* (opencv_videoio),C1394FrameGrabber, FlyCaptureFrameGrabber,
* OpenKinectFrameGrabber,PS3EyeFrameGrabber,VideoInputFrameGrabber, 和
* FFmpegFrameGrabber.
*/
OpenCVFrameGrabber grabber = new OpenCVFrameGrabber(WEBCAM_DEVICE_INDEX);
grabber.setImageWidth(captureWidth);
grabber.setImageHeight(captureHeight);
System.out.println("开始抓取摄像头...");
int isTrue = 0;// 摄像头开启状态
try {
grabber.start();
isTrue += 1;
} catch (org.bytedeco.javacv.FrameGrabber.Exception e2) {
if (grabber != null) {
try {
grabber.restart();
isTrue += 1;
} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
isTrue -= 1;
try {
grabber.stop();
} catch (org.bytedeco.javacv.FrameGrabber.Exception e1) {
isTrue -= 1;
}
}
}
}
if (isTrue < 0) {
System.err.println("摄像头首次开启失败，尝试重启也失败！");
return;
} else if (isTrue < 1) {
System.err.println("摄像头开启失败！");
return;
} else if (isTrue == 1) {
System.err.println("摄像头开启成功！");
} else if (isTrue == 1) {
System.err.println("摄像头首次开启失败，重新启动成功！");
}
/**
* FFmpegFrameRecorder(String filename, int imageWidth, int imageHeight,
* int audioChannels) fileName可以是本地文件（会自动创建），也可以是RTMP路径（发布到流媒体服务器）
* imageWidth = width （为捕获器设置宽） imageHeight = height （为捕获器设置高）
* audioChannels = 2（立体声）；1（单声道）；0（无音频）
*/
FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(outputFile, captureWidth, captureHeight, 2);
recorder.setInterleaved(true);
/**
* 该参数用于降低延迟 参考FFMPEG官方文档：https://trac.ffmpeg.org/wiki/StreamingGuide
* 官方原文参考：ffmpeg -f dshow -i video="Virtual-Camera" -vcodec libx264
* -tune zerolatency -b 900k -f mpegts udp://10.1.0.102:1234
*/
recorder.setVideoOption("tune", "zerolatency");
/**
* 权衡quality(视频质量)和encode speed(编码速度) values(值)：
* ultrafast(终极快),superfast(超级快), veryfast(非常快), faster(很快), fast(快),
* medium(中等), slow(慢), slower(很慢), veryslow(非常慢)
* ultrafast(终极快)提供最少的压缩（低编码器CPU）和最大的视频流大小；而veryslow(非常慢)提供最佳的压缩（高编码器CPU）的同时降低视频流的大小
* 参考：https://trac.ffmpeg.org/wiki/Encode/H.264 官方原文参考：-preset ultrafast
* as the name implies provides for the fastest possible encoding. If
* some tradeoff between quality and encode speed, go for the speed.
* This might be needed if you are going to be transcoding multiple
* streams on one machine.
*/
recorder.setVideoOption("preset", "ultrafast");
/**
* 参考转流命令: ffmpeg
* -i'udp://localhost:5000?fifo_size=1000000&overrun_nonfatal=1' -crf 30
* -preset ultrafast -acodec aac -strict experimental -ar 44100 -ac
* 2-b:a 96k -vcodec libx264 -r 25 -b:v 500k -f flv 'rtmp://<wowza
* serverIP>/live/cam0' -crf 30
* -设置内容速率因子,这是一个x264的动态比特率参数，它能够在复杂场景下(使用不同比特率，即可变比特率)保持视频质量；
* 可以设置更低的质量(quality)和比特率(bit rate),参考Encode/H.264 -preset ultrafast
* -参考上面preset参数，与视频压缩率(视频大小)和速度有关,需要根据情况平衡两大点：压缩率(视频大小)，编/解码速度 -acodec
* aac -设置音频编/解码器 (内部AAC编码) -strict experimental
* -允许使用一些实验的编解码器(比如上面的内部AAC属于实验编解码器) -ar 44100 设置音频采样率(audio sample
* rate) -ac 2 指定双通道音频(即立体声) -b:a 96k 设置音频比特率(bit rate) -vcodec libx264
* 设置视频编解码器(codec) -r 25 -设置帧率(frame rate) -b:v 500k -设置视频比特率(bit
* rate),比特率越高视频越清晰,视频体积也会变大,需要根据实际选择合理范围 -f flv
* -提供输出流封装格式(rtmp协议只支持flv封装格式) 'rtmp://<FMS server
* IP>/live/cam0'-流媒体服务器地址
*/
recorder.setVideoOption("crf", "25");
// 2000 kb/s, 720P视频的合理比特率范围
recorder.setVideoBitrate(2000000);
// h264编/解码器
recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
// 封装格式flv
recorder.setFormat("flv");
// 视频帧率(保证视频质量的情况下最低25，低于25会出现闪屏)
recorder.setFrameRate(FRAME_RATE);
// 关键帧间隔，一般与帧率相同或者是视频帧率的两倍
recorder.setGopSize(FRAME_RATE * 2);
// 不可变(固定)音频比特率
recorder.setAudioOption("crf", "0");
// 最高质量
recorder.setAudioQuality(0);
// 音频比特率
recorder.setAudioBitrate(192000);
// 音频采样率
recorder.setSampleRate(44100);
// 双通道(立体声)
recorder.setAudioChannels(2);
// 音频编/解码器
recorder.setAudioCodec(avcodec.AV_CODEC_ID_AAC);
System.out.println("开始录制...");
try {
recorder.start();
} catch (org.bytedeco.javacv.FrameRecorder.Exception e2) {
if (recorder != null) {
System.out.println("关闭失败，尝试重启");
try {
recorder.stop();
recorder.start();
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
try {
System.out.println("开启失败，关闭录制");
recorder.stop();
return;
} catch (org.bytedeco.javacv.FrameRecorder.Exception e1) {
return;
}
}
}
}
// 音频捕获
new Thread(new Runnable() {
@Override
public void run() {
/**
* 设置音频编码器 最好是系统支持的格式，否则getLine() 会发生错误
* 采样率:44.1k;采样率位数:16位;立体声(stereo);是否签名;true:
* big-endian字节顺序,false:little-endian字节顺序(详见:ByteOrder类)
*/
AudioFormat audioFormat = new AudioFormat(44100.0F, 16, 2, true, false);
// 通过AudioSystem获取本地音频混合器信息
Mixer.Info[] minfoSet = AudioSystem.getMixerInfo();
// 通过AudioSystem获取本地音频混合器
Mixer mixer = AudioSystem.getMixer(minfoSet[AUDIO_DEVICE_INDEX]);
// 通过设置好的音频编解码器获取数据线信息
DataLine.Info dataLineInfo = new DataLine.Info(TargetDataLine.class, audioFormat);
try {
// 打开 <SUF>
// 通过line可以获得更多控制权
// 获取设备：TargetDataLine line
// =(TargetDataLine)mixer.getLine(dataLineInfo);
TargetDataLine line = (TargetDataLine) AudioSystem.getLine(dataLineInfo);
line.open(audioFormat);
line.start();
// 获得当前音频采样率
int sampleRate = (int) audioFormat.getSampleRate();
// 获取当前音频通道数量
int numChannels = audioFormat.getChannels();
// 初始化音频缓冲区(size是音频采样率*通道数)
int audioBufferSize = sampleRate * numChannels;
byte[] audioBytes = new byte[audioBufferSize];
ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
exec.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
// 非阻塞方式读取
int nBytesRead = line.read(audioBytes, 0, line.available());
// 因为我们设置的是16位音频格式,所以需要将byte[]转成short[]
int nSamplesRead = nBytesRead / 2;
short[] samples = new short[nSamplesRead];
/**
* ByteBuffer.wrap(audioBytes)-将byte[]数组包装到缓冲区
* ByteBuffer.order(ByteOrder)-按little-endian修改字节顺序，解码器定义的
* ByteBuffer.asShortBuffer()-创建一个新的short[]缓冲区
* ShortBuffer.get(samples)-将缓冲区里short数据传输到short[]
*/
ByteBuffer.wrap(audioBytes).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(samples);
// 将short[]包装到ShortBuffer
ShortBuffer sBuff = ShortBuffer.wrap(samples, 0, nSamplesRead);
// 按通道录制shortBuffer
recorder.recordSamples(sampleRate, numChannels, sBuff);
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
e.printStackTrace();
}
}
}, 0, (long) 1000 / FRAME_RATE, TimeUnit.MILLISECONDS);
} catch (LineUnavailableException e1) {
e1.printStackTrace();
}
}
}).start();
// javaCV提供了优化非常好的硬件加速组件来帮助显示我们抓取的摄像头视频
CanvasFrame cFrame = new CanvasFrame("Capture Preview", CanvasFrame.getDefaultGamma() / grabber.getGamma());
Frame capturedFrame = null;
// 执行抓取（capture）过程
while ((capturedFrame = grabber.grab()) != null) {
if (cFrame.isVisible()) {
//本机预览要发送的帧
cFrame.showImage(capturedFrame);
}
//定义我们的开始时间，当开始时需要先初始化时间戳
if (startTime == 0)
startTime = System.currentTimeMillis();
// 创建一个 timestamp用来写入帧中
videoTS = 1000 * (System.currentTimeMillis() - startTime);
//检查偏移量
if (videoTS > recorder.getTimestamp()) {
System.out.println("Lip-flap correction: " + videoTS + " : " + recorder.getTimestamp() + " -> "
+ (videoTS - recorder.getTimestamp()));
//告诉录制器写入这个timestamp
recorder.setTimestamp(videoTS);
}
// 发送帧
try {
recorder.record(capturedFrame);
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
System.out.println("录制帧发生异常，什么都不做");
}
}
cFrame.dispose();
try {
if (recorder != null) {
recorder.stop();
}
} catch (org.bytedeco.javacv.FrameRecorder.Exception e) {
System.out.println("关闭录制器失败");
try {
if (recorder != null) {
grabber.stop();
}
} catch (org.bytedeco.javacv.FrameGrabber.Exception e1) {
System.out.println("关闭摄像头失败");
return;
}
}
try {
if (recorder != null) {
grabber.stop();
}
} catch (org.bytedeco.javacv.FrameGrabber.Exception e) {
System.out.println("关闭摄像头失败");
}
}
public static void main(String[] args)
throws Exception {
recordWebcamAndMicrophone(0,4,"E://tmp/aa.flv",700,800,25);
}
}
| true |
47614_2 | package Windows;
import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.List;
public class Home extends JFrame {
DefaultTableModel model;
JTextField nameField;
JTextField amountField;
JComboBox<String> typeBox;
File data;
JTable table;
// 客户管理相关的变量
DefaultTableModel customerModel;
JTextField customerNameField;
JTextField contactField;
ArrayList<String[]> customers = new ArrayList<>();
JTable customerTable;
JComboBox<String> customerBox = new JComboBox<>(getCustomerNames());
File typesFile = new File("./data/types.txt");
ArrayList DeletedCustomers = new ArrayList();;
public Home() throws IOException {
super("LaundroMate");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
int response = JOptionPane.showConfirmDialog(null,"请确保你已经保存。", "是否退出？", JOptionPane.YES_NO_OPTION);
if (response == JOptionPane.YES_OPTION) {
System.exit(0);
} else if (response == JOptionPane.NO_OPTION) {
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
}
});
File customerFile = new File("./data/customers.txt");
BufferedReader customerBr = new BufferedReader(new FileReader(customerFile));
String read;
while ((read = customerBr.readLine())!=null){
customers.add(read.split(","));
}
data = new File("./data/data.txt");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JTabbedPane tabbedPane = new JTabbedPane();
setBounds(600, 300, 900, 600);
setResizable(false);
JPanel AdminPanel = new JPanel();
tabbedPane.addTab("洗衣项目信息", AdminPanel);
JPanel customerPanel = new JPanel();
tabbedPane.addTab("客户信息", customerPanel);
getContentPane().add(tabbedPane);
setLocationRelativeTo(null);
setVisible(true);
//洗衣项目信息管理的一堆控件
JPanel ModifyPanel = new JPanel();
ModifyPanel.setLayout(new BorderLayout());
model = new DefaultTableModel();
model.addColumn("项目名称");
model.addColumn("添加日期");
model.addColumn("项目金额");
model.addColumn("项目类型");
model.addColumn("客户");
try {
Scanner scanner = new Scanner(data);
while (scanner.hasNextLine()) {
String[] rowData = scanner.nextLine().split(",");
model.addRow(rowData);
}
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
table = new JTable(model);
JScrollPane scrollPane = new JScrollPane(table);
ModifyPanel.add(scrollPane, BorderLayout.CENTER);
JPanel inputPanel = new JPanel(new FlowLayout());
nameField = new JTextField(10);
inputPanel.add(new JLabel("项目名称:"));
inputPanel.add(nameField);
amountField = new JTextField(10);
inputPanel.add(new JLabel("项目金额:"));
inputPanel.add(amountField);
File typeFile = new File("./data/types.txt");
BufferedReader br = new BufferedReader(new FileReader(typeFile));
String[] types;
types = br.readLine().split(",");
typeBox = new JComboBox<>(types);
inputPanel.add(new JLabel("项目类型:"));
inputPanel.add(typeBox);
inputPanel.add(new JLabel("客户："));
inputPanel.add(customerBox);
JButton addButton = new JButton("添加");
addButton.addActionListener(new AddButtonListener());
inputPanel.add(addButton);
table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent event) {
if (!event.getValueIsAdjusting() && table.getSelectedRow() != -1) {
nameField.setText(table.getValueAt(table.getSelectedRow(), 0).toString());
amountField.setText(table.getValueAt(table.getSelectedRow(), 2).toString());
typeBox.setSelectedItem(table.getValueAt(table.getSelectedRow(), 3));
}
}
});
JButton deleteButton = new JButton("删除");
deleteButton.addActionListener(new DeleteButtonListener());
inputPanel.add(deleteButton);
ModifyPanel.add(inputPanel, BorderLayout.SOUTH);
AdminPanel.setLayout(new BorderLayout());
AdminPanel.add(ModifyPanel, BorderLayout.CENTER);
// 下面是菜单栏相关的 别弄混了
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("文件");
JMenuItem saveMenuItem = new JMenuItem("保存");
saveMenuItem.addActionListener(new SaveMenuItemListener());
fileMenu.add(saveMenuItem);
JMenuItem searchMenuItem = new JMenuItem("洗衣项目查询");
fileMenu.add(searchMenuItem);
searchMenuItem.addActionListener(new SearchActionListener(table, model));
menuBar.add(fileMenu);
setJMenuBar(menuBar);
customerPanel.setLayout(new BorderLayout());
//客户管理相关的控件
customerModel = new DefaultTableModel();
customerModel.addColumn("客户名");
customerModel.addColumn("联系方式");
customerTable = new JTable(customerModel);
JScrollPane customerScrollPane = new JScrollPane(customerTable);
customerPanel.add(customerScrollPane, BorderLayout.CENTER);
JPanel customerInputPanel = new JPanel(new FlowLayout());
customerNameField = new JTextField(10);
customerInputPanel.add(new JLabel("客户名:"));
customerInputPanel.add(customerNameField);
contactField = new JTextField(10);
customerInputPanel.add(new JLabel("联系方式:"));
customerInputPanel.add(contactField);
JButton addCustomerButton = new JButton("添加客户");
addCustomerButton.addActionListener(new AddCustomerButtonListener());
customerInputPanel.add(addCustomerButton);
JButton deleteCustomerButton = new JButton("删除客户");
deleteCustomerButton.addActionListener(new DeleteCustomerButtonListener());
customerInputPanel.add(deleteCustomerButton);
File customerFile2 = new File("./data/customers.txt");
try {
Scanner scanner = new Scanner(customerFile2);
while (scanner.hasNextLine()) {
String[] rowData = scanner.nextLine().split(",");
customerModel.addRow(rowData);
}
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
customerPanel.add(customerInputPanel, BorderLayout.SOUTH);
//项目类型管理嗷
DefaultTableModel typeModel = new DefaultTableModel();
typeModel.addColumn("类型名称");
JPanel typeManagementPanel = new JPanel(new BorderLayout());
tabbedPane.addTab("类型管理", typeManagementPanel);
JTable typeTable = new JTable(typeModel){
public boolean isCellEditable(int row, int column) {
return false;
}
};
JScrollPane typeScrollPane = new JScrollPane(typeTable);
typeManagementPanel.add(typeScrollPane, BorderLayout.CENTER);
JPanel typeOperationsPanel = new JPanel();
typeManagementPanel.add(typeOperationsPanel, BorderLayout.SOUTH);
JTextField typeField = new JTextField(15);
JButton addTypeButton = new JButton("添加类型");
JButton removeTypeButton = new JButton("删除选中类型");
typeOperationsPanel.add(new JLabel("类型名称:"));
typeOperationsPanel.add(typeField);
typeOperationsPanel.add(addTypeButton);
typeOperationsPanel.add(removeTypeButton);
addTypeButton.addActionListener(new AddTypeButtonListener(typeModel, typeField, typeBox, typesFile));
removeTypeButton.addActionListener(new RemoveTypeButtonListener(typeTable, typeModel, typeBox, typesFile));
File typeFile2 = new File("./data/types.txt");
try {
BufferedReader br2 = new BufferedReader(new FileReader(typeFile2));
String[] types2;
types2 = br2.readLine().split(",");
for (int i=0;i<types2.length;i++){
typeModel.addRow(new Object[]{types2[i]});
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
revalidate();
repaint();
}
class AddButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String name = nameField.getText();
String amount = amountField.getText();
String type = (String) typeBox.getSelectedItem();
if (name.isEmpty() || amount.isEmpty() || type.isEmpty()) {
JOptionPane.showMessageDialog(null, "请确保所有字段都已填写", "错误", JOptionPane.ERROR_MESSAGE);
return;
}
String date = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
String customer = (String) customerBox.getSelectedItem();
model.addRow(new Object[]{name, date, amount, type, customer});
nameField.setText("");
amountField.setText("");
}
}
class DeleteButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int selectedRow = table.getSelectedRow();
if (selectedRow != -1) {
DeletedCustomers.add(selectedRow);
model.removeRow(selectedRow);
}
}
}
class SaveMenuItemListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(data));
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, 0).toString().isEmpty() || model.getValueAt(i, 1).toString().isEmpty() ||
model.getValueAt(i, 2).toString().isEmpty() || model.getValueAt(i, 3).toString().isEmpty()) {
JOptionPane.showMessageDialog(null, "请确保所有字段都已填写", "错误", JOptionPane.ERROR_MESSAGE);
return;
}
writer.write(model.getValueAt(i, 0) + "," + model.getValueAt(i, 1) + ","
+ model.getValueAt(i, 2) + "," + model.getValueAt(i, 3) + "," + model.getValueAt(i, 4));
writer.newLine();
}
writer.close();
for( int i = customerModel.getRowCount() - 1; i >= 0; i-- ) {
String[] customerRow = new String[2];
for (int j = 0; j < customerModel.getColumnCount(); j++) {
customerTable.getValueAt(i, j);
customerRow[j] = customerTable.getValueAt(i, j).toString();
}
}
for (int i = 0; i < DeletedCustomers.size(); i++) {
for (int j = 0; j< customers.size();j++){
if (customers.get(j)[0].equals(DeletedCustomers.get(i))){
customers.remove(j);
}
}
}
BufferedWriter customerWriter = new BufferedWriter(new FileWriter("./data/customers.txt"));
for (String[] customer : customers) {
customerWriter.write(customer[0] + "," + customer[1]);
customerWriter.newLine();
}
customerWriter.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
class SearchActionListener implements ActionListener {
private final JTable table;
private final DefaultTableModel model;
public SearchActionListener(JTable table, DefaultTableModel model) {
this.table = table;
this.model = model;
}
@Override
public void actionPerformed(ActionEvent e) {
JPanel searchInputPanel = new JPanel(new GridLayout(0, 1));
JTextField searchField = new JTextField();
searchInputPanel.add(new JLabel("输入查询条件："));
searchInputPanel.add(searchField);
JTextField lowerBoundField = new JTextField();
JTextField upperBoundField = new JTextField();
searchInputPanel.add(new JLabel("输入金额下限："));
searchInputPanel.add(lowerBoundField);
searchInputPanel.add(new JLabel("输入金额上限："));
searchInputPanel.add(upperBoundField);
ButtonGroup group = new ButtonGroup();
JRadioButton byNameButton = new JRadioButton("按项目名称查询", true);
JRadioButton byDateButton = new JRadioButton("按日期查询");
JRadioButton byAmountButton = new JRadioButton("按项目金额查询");
JRadioButton byTypeButton = new JRadioButton("按项目类型查询");
group.add(byNameButton);
group.add(byDateButton);
group.add(byAmountButton);
group.add(byTypeButton);
searchInputPanel.add(byNameButton);
searchInputPanel.add(byDateButton);
searchInputPanel.add(byAmountButton);
searchInputPanel.add(byTypeButton);
int result = JOptionPane.showConfirmDialog(null, searchInputPanel, "查询", JOptionPane.OK_CANCEL_OPTION);
if (result == JOptionPane.OK_OPTION) {
String searchText = searchField.getText();
int searchColumn = byNameButton.isSelected() ? 0 : (byDateButton.isSelected() ? 1 : (byAmountButton.isSelected() ? 2 : 3));
if (byAmountButton.isSelected()) {
double lowerBound = Double.parseDouble(lowerBoundField.getText());
double upperBound = Double.parseDouble(upperBoundField.getText());
JTable resultTable = new JTable(new DefaultTableModel(new Object[]{"项目名称", "添加日期", "项目金额", "项目类型"}, 0));
JScrollPane scrollPane = new JScrollPane(resultTable);
JFrame resultFrame = new JFrame("查询结果");
resultFrame.add(scrollPane);
resultFrame.setSize(400, 300);
resultFrame.setLocationRelativeTo(null);
for (int i = 0; i < table.getRowCount(); i++) {
double amount = Double.parseDouble(model.getValueAt(i, 2).toString());
if (amount >= lowerBound && amount <= upperBound) {
((DefaultTableModel) resultTable.getModel()).addRow(new Object[]{
model.getValueAt(i, 0),
model.getValueAt(i, 1),
model.getValueAt(i, 2),
model.getValueAt(i, 3)
});
}
}
if (resultTable.getRowCount() > 0) {
resultFrame.setVisible(true);
} else {
JOptionPane.showMessageDialog(null, "未找到匹配的项目。");
}
} else {
for (int i = 0; i < table.getRowCount(); i++) {
if (model.getValueAt(i, searchColumn).equals(searchText)) {
table.setRowSelectionInterval(i, i);
JOptionPane.showMessageDialog(null, "找到匹配的项目。");
return;
}
}
JOptionPane.showMessageDialog(null, "未找到匹配的项目。");
}
}
}
}
class AddCustomerButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
if (!customerNameField.getText().isEmpty() && !contactField.getText().isEmpty()) {
Object[] newCustomer = {customerNameField.getText(), contactField.getText()};
customerModel.addRow(newCustomer);
customerBox.addItem((String)newCustomer[0]);
customers.add(new String[]{customerNameField.getText(), contactField.getText()});
customerNameField.setText("");
contactField.setText("");
} else {
JOptionPane.showMessageDialog(null, "请确保所有字段都已填写", "错误", JOptionPane.ERROR_MESSAGE);
}
}
}
class DeleteCustomerButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int selectedRow = customerTable.getSelectedRow();
if (selectedRow != -1) {
String customerName = (String)customerModel.getValueAt(selectedRow, 0);
customerModel.removeRow(selectedRow);
customerBox.removeItem(customerName);
DeletedCustomers.add(customerName);
customers.remove(customerName);
} else {
JOptionPane.showMessageDialog(null, "请选择一个客户", "错误", JOptionPane.ERROR_MESSAGE);
}
}
}
private String[] getCustomerNames() throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(new File("./data/customers.txt")));
List<String> customers = new ArrayList<>();
String line;
while ((line = reader.readLine()) != null) {
customers.add(line.split(",")[0]);
}
reader.close();
return customers.toArray(new String[0]);
}
class AddTypeButtonListener implements ActionListener {
private DefaultTableModel model;
private JTextField typeField;
private JComboBox<String> typeBox;
private File typesFile;
public AddTypeButtonListener(DefaultTableModel model, JTextField typeField, JComboBox<String> typeBox, File typesFile) {
this.model = model;
this.typeField = typeField;
this.typeBox = typeBox;
this.typesFile = typesFile;
}
@Override
public void actionPerformed(ActionEvent e) {
String newType = typeField.getText();
if (!newType.isEmpty()) {
model.addRow(new Object[]{newType});
typeBox.addItem(newType);
writeTypesToFile();
typeField.setText("");
}
}
private void writeTypesToFile() {
try (PrintWriter writer = new PrintWriter(new FileWriter(typesFile))) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < typeBox.getItemCount(); i++) {
sb.append(typeBox.getItemAt(i));
if (i != typeBox.getItemCount() - 1) {
sb.append(",");
}
}
writer.println(sb.toString());
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
class RemoveTypeButtonListener implements ActionListener {
private JTable table;
private DefaultTableModel model;
private JComboBox<String> typeBox;
private File typesFile;
public RemoveTypeButtonListener(JTable table, DefaultTableModel model, JComboBox<String> typeBox, File typesFile) {
this.table = table;
this.model = model;
this.typeBox = typeBox;
this.typesFile = typesFile;
}
@Override
public void actionPerformed(ActionEvent e) {
int selectedRow = table.getSelectedRow();
if (selectedRow != -1) {
String typeName = (String)model.getValueAt(selectedRow, 0);
model.removeRow(selectedRow);
typeBox.removeItem(typeName);
writeTypesToFile();
} else {
JOptionPane.showMessageDialog(null, "请选择一个类型", "错误", JOptionPane.ERROR_MESSAGE);
}
}
private void writeTypesToFile() {
try (PrintWriter writer = new PrintWriter(new FileWriter(typesFile))) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < typeBox.getItemCount(); i++) {
sb.append(typeBox.getItemAt(i));
if (i != typeBox.getItemCount() - 1) {
sb.append(",");
}
}
writer.println(sb.toString());
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException {
Home home = new Home();
}
} | Lopliter/LaundroMate | src/Windows/Home.java | 4,475 | // 下面是菜单栏相关的 别弄混了 | line_comment | zh-cn | package Windows;
import javax.swing.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.List;
public class Home extends JFrame {
DefaultTableModel model;
JTextField nameField;
JTextField amountField;
JComboBox<String> typeBox;
File data;
JTable table;
// 客户管理相关的变量
DefaultTableModel customerModel;
JTextField customerNameField;
JTextField contactField;
ArrayList<String[]> customers = new ArrayList<>();
JTable customerTable;
JComboBox<String> customerBox = new JComboBox<>(getCustomerNames());
File typesFile = new File("./data/types.txt");
ArrayList DeletedCustomers = new ArrayList();;
public Home() throws IOException {
super("LaundroMate");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
int response = JOptionPane.showConfirmDialog(null,"请确保你已经保存。", "是否退出？", JOptionPane.YES_NO_OPTION);
if (response == JOptionPane.YES_OPTION) {
System.exit(0);
} else if (response == JOptionPane.NO_OPTION) {
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
}
});
File customerFile = new File("./data/customers.txt");
BufferedReader customerBr = new BufferedReader(new FileReader(customerFile));
String read;
while ((read = customerBr.readLine())!=null){
customers.add(read.split(","));
}
data = new File("./data/data.txt");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JTabbedPane tabbedPane = new JTabbedPane();
setBounds(600, 300, 900, 600);
setResizable(false);
JPanel AdminPanel = new JPanel();
tabbedPane.addTab("洗衣项目信息", AdminPanel);
JPanel customerPanel = new JPanel();
tabbedPane.addTab("客户信息", customerPanel);
getContentPane().add(tabbedPane);
setLocationRelativeTo(null);
setVisible(true);
//洗衣项目信息管理的一堆控件
JPanel ModifyPanel = new JPanel();
ModifyPanel.setLayout(new BorderLayout());
model = new DefaultTableModel();
model.addColumn("项目名称");
model.addColumn("添加日期");
model.addColumn("项目金额");
model.addColumn("项目类型");
model.addColumn("客户");
try {
Scanner scanner = new Scanner(data);
while (scanner.hasNextLine()) {
String[] rowData = scanner.nextLine().split(",");
model.addRow(rowData);
}
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
table = new JTable(model);
JScrollPane scrollPane = new JScrollPane(table);
ModifyPanel.add(scrollPane, BorderLayout.CENTER);
JPanel inputPanel = new JPanel(new FlowLayout());
nameField = new JTextField(10);
inputPanel.add(new JLabel("项目名称:"));
inputPanel.add(nameField);
amountField = new JTextField(10);
inputPanel.add(new JLabel("项目金额:"));
inputPanel.add(amountField);
File typeFile = new File("./data/types.txt");
BufferedReader br = new BufferedReader(new FileReader(typeFile));
String[] types;
types = br.readLine().split(",");
typeBox = new JComboBox<>(types);
inputPanel.add(new JLabel("项目类型:"));
inputPanel.add(typeBox);
inputPanel.add(new JLabel("客户："));
inputPanel.add(customerBox);
JButton addButton = new JButton("添加");
addButton.addActionListener(new AddButtonListener());
inputPanel.add(addButton);
table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
public void valueChanged(ListSelectionEvent event) {
if (!event.getValueIsAdjusting() && table.getSelectedRow() != -1) {
nameField.setText(table.getValueAt(table.getSelectedRow(), 0).toString());
amountField.setText(table.getValueAt(table.getSelectedRow(), 2).toString());
typeBox.setSelectedItem(table.getValueAt(table.getSelectedRow(), 3));
}
}
});
JButton deleteButton = new JButton("删除");
deleteButton.addActionListener(new DeleteButtonListener());
inputPanel.add(deleteButton);
ModifyPanel.add(inputPanel, BorderLayout.SOUTH);
AdminPanel.setLayout(new BorderLayout());
AdminPanel.add(ModifyPanel, BorderLayout.CENTER);
// 下面 <SUF>
JMenuBar menuBar = new JMenuBar();
JMenu fileMenu = new JMenu("文件");
JMenuItem saveMenuItem = new JMenuItem("保存");
saveMenuItem.addActionListener(new SaveMenuItemListener());
fileMenu.add(saveMenuItem);
JMenuItem searchMenuItem = new JMenuItem("洗衣项目查询");
fileMenu.add(searchMenuItem);
searchMenuItem.addActionListener(new SearchActionListener(table, model));
menuBar.add(fileMenu);
setJMenuBar(menuBar);
customerPanel.setLayout(new BorderLayout());
//客户管理相关的控件
customerModel = new DefaultTableModel();
customerModel.addColumn("客户名");
customerModel.addColumn("联系方式");
customerTable = new JTable(customerModel);
JScrollPane customerScrollPane = new JScrollPane(customerTable);
customerPanel.add(customerScrollPane, BorderLayout.CENTER);
JPanel customerInputPanel = new JPanel(new FlowLayout());
customerNameField = new JTextField(10);
customerInputPanel.add(new JLabel("客户名:"));
customerInputPanel.add(customerNameField);
contactField = new JTextField(10);
customerInputPanel.add(new JLabel("联系方式:"));
customerInputPanel.add(contactField);
JButton addCustomerButton = new JButton("添加客户");
addCustomerButton.addActionListener(new AddCustomerButtonListener());
customerInputPanel.add(addCustomerButton);
JButton deleteCustomerButton = new JButton("删除客户");
deleteCustomerButton.addActionListener(new DeleteCustomerButtonListener());
customerInputPanel.add(deleteCustomerButton);
File customerFile2 = new File("./data/customers.txt");
try {
Scanner scanner = new Scanner(customerFile2);
while (scanner.hasNextLine()) {
String[] rowData = scanner.nextLine().split(",");
customerModel.addRow(rowData);
}
scanner.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
customerPanel.add(customerInputPanel, BorderLayout.SOUTH);
//项目类型管理嗷
DefaultTableModel typeModel = new DefaultTableModel();
typeModel.addColumn("类型名称");
JPanel typeManagementPanel = new JPanel(new BorderLayout());
tabbedPane.addTab("类型管理", typeManagementPanel);
JTable typeTable = new JTable(typeModel){
public boolean isCellEditable(int row, int column) {
return false;
}
};
JScrollPane typeScrollPane = new JScrollPane(typeTable);
typeManagementPanel.add(typeScrollPane, BorderLayout.CENTER);
JPanel typeOperationsPanel = new JPanel();
typeManagementPanel.add(typeOperationsPanel, BorderLayout.SOUTH);
JTextField typeField = new JTextField(15);
JButton addTypeButton = new JButton("添加类型");
JButton removeTypeButton = new JButton("删除选中类型");
typeOperationsPanel.add(new JLabel("类型名称:"));
typeOperationsPanel.add(typeField);
typeOperationsPanel.add(addTypeButton);
typeOperationsPanel.add(removeTypeButton);
addTypeButton.addActionListener(new AddTypeButtonListener(typeModel, typeField, typeBox, typesFile));
removeTypeButton.addActionListener(new RemoveTypeButtonListener(typeTable, typeModel, typeBox, typesFile));
File typeFile2 = new File("./data/types.txt");
try {
BufferedReader br2 = new BufferedReader(new FileReader(typeFile2));
String[] types2;
types2 = br2.readLine().split(",");
for (int i=0;i<types2.length;i++){
typeModel.addRow(new Object[]{types2[i]});
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
revalidate();
repaint();
}
class AddButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String name = nameField.getText();
String amount = amountField.getText();
String type = (String) typeBox.getSelectedItem();
if (name.isEmpty() || amount.isEmpty() || type.isEmpty()) {
JOptionPane.showMessageDialog(null, "请确保所有字段都已填写", "错误", JOptionPane.ERROR_MESSAGE);
return;
}
String date = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
String customer = (String) customerBox.getSelectedItem();
model.addRow(new Object[]{name, date, amount, type, customer});
nameField.setText("");
amountField.setText("");
}
}
class DeleteButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int selectedRow = table.getSelectedRow();
if (selectedRow != -1) {
DeletedCustomers.add(selectedRow);
model.removeRow(selectedRow);
}
}
}
class SaveMenuItemListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(data));
for (int i = 0; i < model.getRowCount(); i++) {
if (model.getValueAt(i, 0).toString().isEmpty() || model.getValueAt(i, 1).toString().isEmpty() ||
model.getValueAt(i, 2).toString().isEmpty() || model.getValueAt(i, 3).toString().isEmpty()) {
JOptionPane.showMessageDialog(null, "请确保所有字段都已填写", "错误", JOptionPane.ERROR_MESSAGE);
return;
}
writer.write(model.getValueAt(i, 0) + "," + model.getValueAt(i, 1) + ","
+ model.getValueAt(i, 2) + "," + model.getValueAt(i, 3) + "," + model.getValueAt(i, 4));
writer.newLine();
}
writer.close();
for( int i = customerModel.getRowCount() - 1; i >= 0; i-- ) {
String[] customerRow = new String[2];
for (int j = 0; j < customerModel.getColumnCount(); j++) {
customerTable.getValueAt(i, j);
customerRow[j] = customerTable.getValueAt(i, j).toString();
}
}
for (int i = 0; i < DeletedCustomers.size(); i++) {
for (int j = 0; j< customers.size();j++){
if (customers.get(j)[0].equals(DeletedCustomers.get(i))){
customers.remove(j);
}
}
}
BufferedWriter customerWriter = new BufferedWriter(new FileWriter("./data/customers.txt"));
for (String[] customer : customers) {
customerWriter.write(customer[0] + "," + customer[1]);
customerWriter.newLine();
}
customerWriter.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
class SearchActionListener implements ActionListener {
private final JTable table;
private final DefaultTableModel model;
public SearchActionListener(JTable table, DefaultTableModel model) {
this.table = table;
this.model = model;
}
@Override
public void actionPerformed(ActionEvent e) {
JPanel searchInputPanel = new JPanel(new GridLayout(0, 1));
JTextField searchField = new JTextField();
searchInputPanel.add(new JLabel("输入查询条件："));
searchInputPanel.add(searchField);
JTextField lowerBoundField = new JTextField();
JTextField upperBoundField = new JTextField();
searchInputPanel.add(new JLabel("输入金额下限："));
searchInputPanel.add(lowerBoundField);
searchInputPanel.add(new JLabel("输入金额上限："));
searchInputPanel.add(upperBoundField);
ButtonGroup group = new ButtonGroup();
JRadioButton byNameButton = new JRadioButton("按项目名称查询", true);
JRadioButton byDateButton = new JRadioButton("按日期查询");
JRadioButton byAmountButton = new JRadioButton("按项目金额查询");
JRadioButton byTypeButton = new JRadioButton("按项目类型查询");
group.add(byNameButton);
group.add(byDateButton);
group.add(byAmountButton);
group.add(byTypeButton);
searchInputPanel.add(byNameButton);
searchInputPanel.add(byDateButton);
searchInputPanel.add(byAmountButton);
searchInputPanel.add(byTypeButton);
int result = JOptionPane.showConfirmDialog(null, searchInputPanel, "查询", JOptionPane.OK_CANCEL_OPTION);
if (result == JOptionPane.OK_OPTION) {
String searchText = searchField.getText();
int searchColumn = byNameButton.isSelected() ? 0 : (byDateButton.isSelected() ? 1 : (byAmountButton.isSelected() ? 2 : 3));
if (byAmountButton.isSelected()) {
double lowerBound = Double.parseDouble(lowerBoundField.getText());
double upperBound = Double.parseDouble(upperBoundField.getText());
JTable resultTable = new JTable(new DefaultTableModel(new Object[]{"项目名称", "添加日期", "项目金额", "项目类型"}, 0));
JScrollPane scrollPane = new JScrollPane(resultTable);
JFrame resultFrame = new JFrame("查询结果");
resultFrame.add(scrollPane);
resultFrame.setSize(400, 300);
resultFrame.setLocationRelativeTo(null);
for (int i = 0; i < table.getRowCount(); i++) {
double amount = Double.parseDouble(model.getValueAt(i, 2).toString());
if (amount >= lowerBound && amount <= upperBound) {
((DefaultTableModel) resultTable.getModel()).addRow(new Object[]{
model.getValueAt(i, 0),
model.getValueAt(i, 1),
model.getValueAt(i, 2),
model.getValueAt(i, 3)
});
}
}
if (resultTable.getRowCount() > 0) {
resultFrame.setVisible(true);
} else {
JOptionPane.showMessageDialog(null, "未找到匹配的项目。");
}
} else {
for (int i = 0; i < table.getRowCount(); i++) {
if (model.getValueAt(i, searchColumn).equals(searchText)) {
table.setRowSelectionInterval(i, i);
JOptionPane.showMessageDialog(null, "找到匹配的项目。");
return;
}
}
JOptionPane.showMessageDialog(null, "未找到匹配的项目。");
}
}
}
}
class AddCustomerButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
if (!customerNameField.getText().isEmpty() && !contactField.getText().isEmpty()) {
Object[] newCustomer = {customerNameField.getText(), contactField.getText()};
customerModel.addRow(newCustomer);
customerBox.addItem((String)newCustomer[0]);
customers.add(new String[]{customerNameField.getText(), contactField.getText()});
customerNameField.setText("");
contactField.setText("");
} else {
JOptionPane.showMessageDialog(null, "请确保所有字段都已填写", "错误", JOptionPane.ERROR_MESSAGE);
}
}
}
class DeleteCustomerButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int selectedRow = customerTable.getSelectedRow();
if (selectedRow != -1) {
String customerName = (String)customerModel.getValueAt(selectedRow, 0);
customerModel.removeRow(selectedRow);
customerBox.removeItem(customerName);
DeletedCustomers.add(customerName);
customers.remove(customerName);
} else {
JOptionPane.showMessageDialog(null, "请选择一个客户", "错误", JOptionPane.ERROR_MESSAGE);
}
}
}
private String[] getCustomerNames() throws IOException {
BufferedReader reader = new BufferedReader(new FileReader(new File("./data/customers.txt")));
List<String> customers = new ArrayList<>();
String line;
while ((line = reader.readLine()) != null) {
customers.add(line.split(",")[0]);
}
reader.close();
return customers.toArray(new String[0]);
}
class AddTypeButtonListener implements ActionListener {
private DefaultTableModel model;
private JTextField typeField;
private JComboBox<String> typeBox;
private File typesFile;
public AddTypeButtonListener(DefaultTableModel model, JTextField typeField, JComboBox<String> typeBox, File typesFile) {
this.model = model;
this.typeField = typeField;
this.typeBox = typeBox;
this.typesFile = typesFile;
}
@Override
public void actionPerformed(ActionEvent e) {
String newType = typeField.getText();
if (!newType.isEmpty()) {
model.addRow(new Object[]{newType});
typeBox.addItem(newType);
writeTypesToFile();
typeField.setText("");
}
}
private void writeTypesToFile() {
try (PrintWriter writer = new PrintWriter(new FileWriter(typesFile))) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < typeBox.getItemCount(); i++) {
sb.append(typeBox.getItemAt(i));
if (i != typeBox.getItemCount() - 1) {
sb.append(",");
}
}
writer.println(sb.toString());
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
class RemoveTypeButtonListener implements ActionListener {
private JTable table;
private DefaultTableModel model;
private JComboBox<String> typeBox;
private File typesFile;
public RemoveTypeButtonListener(JTable table, DefaultTableModel model, JComboBox<String> typeBox, File typesFile) {
this.table = table;
this.model = model;
this.typeBox = typeBox;
this.typesFile = typesFile;
}
@Override
public void actionPerformed(ActionEvent e) {
int selectedRow = table.getSelectedRow();
if (selectedRow != -1) {
String typeName = (String)model.getValueAt(selectedRow, 0);
model.removeRow(selectedRow);
typeBox.removeItem(typeName);
writeTypesToFile();
} else {
JOptionPane.showMessageDialog(null, "请选择一个类型", "错误", JOptionPane.ERROR_MESSAGE);
}
}
private void writeTypesToFile() {
try (PrintWriter writer = new PrintWriter(new FileWriter(typesFile))) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < typeBox.getItemCount(); i++) {
sb.append(typeBox.getItemAt(i));
if (i != typeBox.getItemCount() - 1) {
sb.append(",");
}
}
writer.println(sb.toString());
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException {
Home home = new Home();
}
} | false |
21900_2 | package model;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Iterator;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.naming.spi.DirStateFactory.Result;
import utilitiy.MyBase64;
public class Mail {
String subject = "";
String from = "";
Vector<String> to_list = new Vector<String>();
String content = "";
public Mail(String subject, String from, Vector<String> to_list,
String content) {
super();
this.subject = subject;
this.from = from;
this.to_list = to_list;
this.content = content;
}
public Mail(Vector<String> lines) {
super();
initByLines(lines);
}
private void initByLines(Vector<String> lines) {
//决定当前行是否解码
boolean decodeWithBase64 = false;
//排除前一行的干扰
boolean isPreLine = false;
//是否已经收集完内容 不要html
boolean hasContent = false;
for (int i = 0; i < lines.size(); i++) {
String buf = lines.get(i);
isPreLine = false;
if (buf.startsWith("Return-Path:")) {
String regex = "<(.*)>";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(buf);
boolean cont = true;
while (m.find()) {
// System.out.println(m.group(1));
if (cont) {
to_list = new Vector<>();
to_list.addElement(m.group(1));
cont = false;
}
}
}else if (buf.startsWith("Subject:")) {
boolean isUTF8 = false;
String regex = "=\\?(?i)UTF-8\\?B\\?(.*)\\?=";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(buf);
while (m.find()) {
isUTF8 = true;
subject = MyBase64.getFromBASE64(m.group(1));
}
if(!isUTF8) subject = buf.substring(8);
}else if (buf.startsWith("From:")) {
from = buf.substring(5);
}else if (buf.endsWith("base64")) {
if(!hasContent){
decodeWithBase64 = true;
isPreLine = true;
}
hasContent = true;
}else if (buf.startsWith("--")) {
decodeWithBase64 = false;
}
if (decodeWithBase64 && !isPreLine) {
content += MyBase64.getFromBASE64(buf);
}
}
}
public String getDataString() {
String to = "";
for (int i = 0; i < to_list.size(); i++) {
to += to_list.get(i) + ";";
}
String result = "From:" + from + "\r\n" + "To:" + to + "\r\n"
+ "Subject:" + subject + "\r\n" + content + "\r\n";
return result;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public Vector<String> getTo_list() {
return to_list;
}
public void setTo_list(Vector<String> to_list) {
this.to_list = to_list;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
String to = "";
for (int i = 0; i < to_list.size(); i++) {
to+= to_list.get(i)+";";
}
return "主题:"+subject+"\r\n"+
"来自:"+from+"\r\n"+
"回复:"+to+"\r\n"+
"正文:"+content;
}
}
| LoranWong/SimpleEmailClient | src/model/Mail.java | 1,112 | //是否已经收集完内容 不要html | line_comment | zh-cn | package model;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Iterator;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.naming.spi.DirStateFactory.Result;
import utilitiy.MyBase64;
public class Mail {
String subject = "";
String from = "";
Vector<String> to_list = new Vector<String>();
String content = "";
public Mail(String subject, String from, Vector<String> to_list,
String content) {
super();
this.subject = subject;
this.from = from;
this.to_list = to_list;
this.content = content;
}
public Mail(Vector<String> lines) {
super();
initByLines(lines);
}
private void initByLines(Vector<String> lines) {
//决定当前行是否解码
boolean decodeWithBase64 = false;
//排除前一行的干扰
boolean isPreLine = false;
//是否 <SUF>
boolean hasContent = false;
for (int i = 0; i < lines.size(); i++) {
String buf = lines.get(i);
isPreLine = false;
if (buf.startsWith("Return-Path:")) {
String regex = "<(.*)>";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(buf);
boolean cont = true;
while (m.find()) {
// System.out.println(m.group(1));
if (cont) {
to_list = new Vector<>();
to_list.addElement(m.group(1));
cont = false;
}
}
}else if (buf.startsWith("Subject:")) {
boolean isUTF8 = false;
String regex = "=\\?(?i)UTF-8\\?B\\?(.*)\\?=";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(buf);
while (m.find()) {
isUTF8 = true;
subject = MyBase64.getFromBASE64(m.group(1));
}
if(!isUTF8) subject = buf.substring(8);
}else if (buf.startsWith("From:")) {
from = buf.substring(5);
}else if (buf.endsWith("base64")) {
if(!hasContent){
decodeWithBase64 = true;
isPreLine = true;
}
hasContent = true;
}else if (buf.startsWith("--")) {
decodeWithBase64 = false;
}
if (decodeWithBase64 && !isPreLine) {
content += MyBase64.getFromBASE64(buf);
}
}
}
public String getDataString() {
String to = "";
for (int i = 0; i < to_list.size(); i++) {
to += to_list.get(i) + ";";
}
String result = "From:" + from + "\r\n" + "To:" + to + "\r\n"
+ "Subject:" + subject + "\r\n" + content + "\r\n";
return result;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public Vector<String> getTo_list() {
return to_list;
}
public void setTo_list(Vector<String> to_list) {
this.to_list = to_list;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
String to = "";
for (int i = 0; i < to_list.size(); i++) {
to+= to_list.get(i)+";";
}
return "主题:"+subject+"\r\n"+
"来自:"+from+"\r\n"+
"回复:"+to+"\r\n"+
"正文:"+content;
}
}
| false |
42531_0 | package file;
import javabase.lorenwang.tools.file.JtlwFileOptionUtil;
/**
* 功能作用：清除指定目录空文件夹目录
* 初始注释时间： 2022/2/7 10:34
* 创建人：王亮（Loren）
* 思路：
* 方法：
* 注意：
* 修改人：
* 修改时间：
* 备注：
*
* @author 王亮（Loren）
*/
public class ClearEmptyFileDir {
public static void main(String[] args) {
JtlwFileOptionUtil.getInstance().clearEmptyFileDir("/Volumes/DataStorege/私人/备份文件/手机备份",
(filePath, status) -> System.out.println("清除文件夹：" + filePath + "，清除状态：" + status));
}
}
| Loren-Wang/LorenWangCustomTools | JavaPcToolsFromLorenWang/src/file/ClearEmptyFileDir.java | 206 | /**
* 功能作用：清除指定目录空文件夹目录
* 初始注释时间： 2022/2/7 10:34
* 创建人：王亮（Loren）
* 思路：
* 方法：
* 注意：
* 修改人：
* 修改时间：
* 备注：
*
* @author 王亮（Loren）
*/ | block_comment | zh-cn | package file;
import javabase.lorenwang.tools.file.JtlwFileOptionUtil;
/**
* 功能作 <SUF>*/
public class ClearEmptyFileDir {
public static void main(String[] args) {
JtlwFileOptionUtil.getInstance().clearEmptyFileDir("/Volumes/DataStorege/私人/备份文件/手机备份",
(filePath, status) -> System.out.println("清除文件夹：" + filePath + "，清除状态：" + status));
}
}
| false |
30817_2 | import java.util.List;
import java.util.ArrayList;
public class No93 {
public static void main(String[] args) {
System.out.println(new Solution().restoreIpAddresses("25525011135"));
}
static class Solution {
List<String> result = new ArrayList<String>();
String s;
public List<String> restoreIpAddresses(String s) {
this.s = s;
int[] path = new int[4];
backTrack(0, path, 0);
return result;
}
private void backTrack(int count, int[] path, int itr){
//找到解集
if(count == 4){
result.add(arrayToString(path));
return;
}else{
//截取数字区间不合理 | 截取的数字过大--截取长度减少
//截取长度小于0--向前回溯,回溯到上一个数字
for(int len = 1; len <= 3; len++){
int maxL = (3 - count) * 3;
int minL = 3 - count;
if(maxL < s.length()-len-itr) continue;
if(minL > s.length()-len-itr) return;
if(s.charAt(itr) == '0' && len != 1) return;
int i = Integer.parseInt(s, itr, itr+len, 10);
if(i < 256){
path[count] = i;
backTrack(count+1, path, itr+len);
path[count] = -1;
}else return;
}
}
}
private String arrayToString(int[] path){
String res = "";
res += path[0];
for(int i = 1; i < 4; i++) res = res + "." + path[i];
return res;
}
}
} | LosLiSang/LeetCode2020 | No93.java | 449 | //截取长度小于0--向前回溯,回溯到上一个数字 | line_comment | zh-cn | import java.util.List;
import java.util.ArrayList;
public class No93 {
public static void main(String[] args) {
System.out.println(new Solution().restoreIpAddresses("25525011135"));
}
static class Solution {
List<String> result = new ArrayList<String>();
String s;
public List<String> restoreIpAddresses(String s) {
this.s = s;
int[] path = new int[4];
backTrack(0, path, 0);
return result;
}
private void backTrack(int count, int[] path, int itr){
//找到解集
if(count == 4){
result.add(arrayToString(path));
return;
}else{
//截取数字区间不合理 | 截取的数字过大--截取长度减少
//截取 <SUF>
for(int len = 1; len <= 3; len++){
int maxL = (3 - count) * 3;
int minL = 3 - count;
if(maxL < s.length()-len-itr) continue;
if(minL > s.length()-len-itr) return;
if(s.charAt(itr) == '0' && len != 1) return;
int i = Integer.parseInt(s, itr, itr+len, 10);
if(i < 256){
path[count] = i;
backTrack(count+1, path, itr+len);
path[count] = -1;
}else return;
}
}
}
private String arrayToString(int[] path){
String res = "";
res += path[0];
for(int i = 1; i < 4; i++) res = res + "." + path[i];
return res;
}
}
} | true |
15430_20 | package UI;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.File;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
//框架设置。
public class FaceUI{
JFrame mJFrame = new JFrame();
private MyConform myConform; //定义私有接口实现回调。
private String ReadfileName = null; //输入文件名称。
private String OutPutFoldName = null; //输出文件夹名。
private String OutPutEnglishName = "EnglisFormat.txt"; //格式化之后的英文名称
private String OutPutChineseName = "ChineseAndEnglishFormat.txt"; //格式化之后的中文文件名称
private boolean TranslateToChinese = true; //判断需要翻译的类型 默认是翻译成中文
private boolean TranslateToEnglish = false;
public boolean getTranslateToChinese() {
return TranslateToChinese;
}
public boolean getTranslateToEnglish() {
return TranslateToEnglish;
}
public void setTranslateToChinese(boolean TranslateToChinese) {
this.TranslateToChinese = TranslateToChinese;
}
public void setTranslateToEnglish(boolean TranslateToEnglish) {
this.TranslateToEnglish = TranslateToEnglish;
}
public String getReadfileName() {
return ReadfileName;
}
public String getOutPutFoldName() {
return OutPutFoldName;
}
public String getOutPutChineseName() {
return OutPutChineseName;
}
public String getOutPutEnglishName() {
return OutPutEnglishName;
}
//初始化一个UI
public void initUI(JFrame jf) {
//frame 相当于桌子，jPanel为桌布，按钮为杯子放在桌布上。
JPanel jpanel=new JPanel();
jpanel.setLayout(null);
Container c=jf.getContentPane();
jf.setLayout(null);
c.add(jpanel);
JButton bt1,bt2,bt3;
JLabel l1,l2,l3;
JLabel label=new JLabel("选择翻译类型");
l1 = new JLabel("");
l2 = new JLabel("");
l3 = new JLabel("");
bt1=new JButton("请选择文件：");
bt1.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
JFileChooser jfc=new JFileChooser();
//显示文件和目录
jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES );
jfc.showDialog(new JLabel(), "选择");
File file=jfc.getSelectedFile();
//file.getAbsolutePath()获取到的绝对路径。
if(file.isDirectory()){
System.out.println("请重新选择文件！不能是文件夹！");
}else if(file.isFile()){
System.out.println("文件:"+file.getAbsolutePath());
ReadfileName = file.getAbsolutePath(); //获取到文件名，即读入文件名。
l1.setText(ReadfileName);
}
}
});
bt2=new JButton("请选择输出文件夹：");
bt2.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
JFileChooser jfc=new JFileChooser();
//显示文件和目录
jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES );
jfc.showDialog(new JLabel(), "选择");
File file=jfc.getSelectedFile();
//file.getAbsolutePath()获取到的绝对路径。
if(file.isDirectory()){
System.out.println("文件夹:"+file.getAbsolutePath());
OutPutFoldName = file.getAbsolutePath() + "\\" ;//获取到文件夹名
l2.setText(OutPutFoldName);
}else if(file.isFile()){
System.out.println("请选择文件夹！");
}
}
});
bt3=new JButton("提交");
bt3.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
try {
myConform.doConfirm();
l3.setText("提交成功！");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
// 需要选择的条目
String[] listData = new String[]{"中文->英文", "英文->中文"};
// 创建一个下拉列表框
final JComboBox<String> comboBox = new JComboBox<String>(listData);
// 设置默认选中的条目
comboBox.setSelectedIndex(1);
// 添加条目选中状态改变的监听器
comboBox.addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
// 只处理选中的状态
if (e.getStateChange() == ItemEvent.SELECTED) {
if (comboBox.getSelectedIndex() == 0) {
TranslateToEnglish = true;
// System.out.println("选中: " + comboBox.getSelectedIndex() + " = " + comboBox.getSelectedItem());
}else {
TranslateToChinese = true;
// System.out.println("选中: " + comboBox.getSelectedIndex() + " = " + comboBox.getSelectedItem());
}
}
}
});
l1.setText("初始文件路径");
l2.setText("输出文件夹");
l3.setText("");
//前俩参数设置位置， 后俩参数设置 大小。
bt1.setBounds(20,10,170,20);
l1.setBounds(200,10,800,20);
bt2.setBounds(20,50,170,20);
l2.setBounds(200,50,400,20);
bt3.setBounds(20,90,100,20);
l3.setBounds(200,90,170,20);
//第四行
label.setBounds(20,130,170,20);
comboBox.setBounds(200,130,170,20);
jpanel.add(bt1);
jpanel.add(bt2);
jpanel.add(bt3);
// jpanel.add(label);
// jpanel.add(comboBox);
jpanel.add(l1);
jpanel.add(l2);
jpanel.add(l3);
jf.setSize(500, 200);
jpanel.setSize(500, 200);
jf.setVisible(true);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public interface MyConform{
void doConfirm() throws Exception ;
};
public void registerMyConform(MyConform myConform) {
this.myConform = myConform;
}
}
| LostStarTvT/JavaAutoTranslate | src/UI/FaceUI.java | 1,751 | // 设置默认选中的条目 | line_comment | zh-cn | package UI;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.File;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
//框架设置。
public class FaceUI{
JFrame mJFrame = new JFrame();
private MyConform myConform; //定义私有接口实现回调。
private String ReadfileName = null; //输入文件名称。
private String OutPutFoldName = null; //输出文件夹名。
private String OutPutEnglishName = "EnglisFormat.txt"; //格式化之后的英文名称
private String OutPutChineseName = "ChineseAndEnglishFormat.txt"; //格式化之后的中文文件名称
private boolean TranslateToChinese = true; //判断需要翻译的类型 默认是翻译成中文
private boolean TranslateToEnglish = false;
public boolean getTranslateToChinese() {
return TranslateToChinese;
}
public boolean getTranslateToEnglish() {
return TranslateToEnglish;
}
public void setTranslateToChinese(boolean TranslateToChinese) {
this.TranslateToChinese = TranslateToChinese;
}
public void setTranslateToEnglish(boolean TranslateToEnglish) {
this.TranslateToEnglish = TranslateToEnglish;
}
public String getReadfileName() {
return ReadfileName;
}
public String getOutPutFoldName() {
return OutPutFoldName;
}
public String getOutPutChineseName() {
return OutPutChineseName;
}
public String getOutPutEnglishName() {
return OutPutEnglishName;
}
//初始化一个UI
public void initUI(JFrame jf) {
//frame 相当于桌子，jPanel为桌布，按钮为杯子放在桌布上。
JPanel jpanel=new JPanel();
jpanel.setLayout(null);
Container c=jf.getContentPane();
jf.setLayout(null);
c.add(jpanel);
JButton bt1,bt2,bt3;
JLabel l1,l2,l3;
JLabel label=new JLabel("选择翻译类型");
l1 = new JLabel("");
l2 = new JLabel("");
l3 = new JLabel("");
bt1=new JButton("请选择文件：");
bt1.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
JFileChooser jfc=new JFileChooser();
//显示文件和目录
jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES );
jfc.showDialog(new JLabel(), "选择");
File file=jfc.getSelectedFile();
//file.getAbsolutePath()获取到的绝对路径。
if(file.isDirectory()){
System.out.println("请重新选择文件！不能是文件夹！");
}else if(file.isFile()){
System.out.println("文件:"+file.getAbsolutePath());
ReadfileName = file.getAbsolutePath(); //获取到文件名，即读入文件名。
l1.setText(ReadfileName);
}
}
});
bt2=new JButton("请选择输出文件夹：");
bt2.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
JFileChooser jfc=new JFileChooser();
//显示文件和目录
jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES );
jfc.showDialog(new JLabel(), "选择");
File file=jfc.getSelectedFile();
//file.getAbsolutePath()获取到的绝对路径。
if(file.isDirectory()){
System.out.println("文件夹:"+file.getAbsolutePath());
OutPutFoldName = file.getAbsolutePath() + "\\" ;//获取到文件夹名
l2.setText(OutPutFoldName);
}else if(file.isFile()){
System.out.println("请选择文件夹！");
}
}
});
bt3=new JButton("提交");
bt3.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
try {
myConform.doConfirm();
l3.setText("提交成功！");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
// 需要选择的条目
String[] listData = new String[]{"中文->英文", "英文->中文"};
// 创建一个下拉列表框
final JComboBox<String> comboBox = new JComboBox<String>(listData);
// 设置 <SUF>
comboBox.setSelectedIndex(1);
// 添加条目选中状态改变的监听器
comboBox.addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
// 只处理选中的状态
if (e.getStateChange() == ItemEvent.SELECTED) {
if (comboBox.getSelectedIndex() == 0) {
TranslateToEnglish = true;
// System.out.println("选中: " + comboBox.getSelectedIndex() + " = " + comboBox.getSelectedItem());
}else {
TranslateToChinese = true;
// System.out.println("选中: " + comboBox.getSelectedIndex() + " = " + comboBox.getSelectedItem());
}
}
}
});
l1.setText("初始文件路径");
l2.setText("输出文件夹");
l3.setText("");
//前俩参数设置位置， 后俩参数设置 大小。
bt1.setBounds(20,10,170,20);
l1.setBounds(200,10,800,20);
bt2.setBounds(20,50,170,20);
l2.setBounds(200,50,400,20);
bt3.setBounds(20,90,100,20);
l3.setBounds(200,90,170,20);
//第四行
label.setBounds(20,130,170,20);
comboBox.setBounds(200,130,170,20);
jpanel.add(bt1);
jpanel.add(bt2);
jpanel.add(bt3);
// jpanel.add(label);
// jpanel.add(comboBox);
jpanel.add(l1);
jpanel.add(l2);
jpanel.add(l3);
jf.setSize(500, 200);
jpanel.setSize(500, 200);
jf.setVisible(true);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public interface MyConform{
void doConfirm() throws Exception ;
};
public void registerMyConform(MyConform myConform) {
this.myConform = myConform;
}
}
| true |
59720_5 | package top.lothar.sdims.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import top.lothar.sdims.entity.User;
public class PurchaseLoginInterceptor extends HandlerInterceptorAdapter{
/*
* 主要做事前拦截，即用户操作发生前，改写preHandle里的逻辑，进行拦截 个人理解 ：在调用指定的controller前进行身份拦截
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 先从session中取出用户信息
Object objectUser = request.getSession().getAttribute("loginUser");
// 对用户信息进行判断
if (objectUser != null) {
// 用户信息不为空，则将其转换为PersonInfo
User user = (User) objectUser;
// 对user进行判断userId和角色类型
if (user != null && user.getUserId()> 0) {
if (user.getRole().getRoleId()==1 || user.getRole().getRoleId()==3) {
// 如果通过上述的验证步骤，则返回true，可以进行接下来操作
return true;
}else {
System.out.println("无权限");
return false;
}
}
}
// 不满足验证，则直接跳转到登录页面
response.sendRedirect(request.getContextPath());
return false;
}
}
| Lotharing/SDIMS | src/main/java/top/lothar/sdims/interceptor/PurchaseLoginInterceptor.java | 365 | // 如果通过上述的验证步骤，则返回true，可以进行接下来操作 | line_comment | zh-cn | package top.lothar.sdims.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import top.lothar.sdims.entity.User;
public class PurchaseLoginInterceptor extends HandlerInterceptorAdapter{
/*
* 主要做事前拦截，即用户操作发生前，改写preHandle里的逻辑，进行拦截 个人理解 ：在调用指定的controller前进行身份拦截
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 先从session中取出用户信息
Object objectUser = request.getSession().getAttribute("loginUser");
// 对用户信息进行判断
if (objectUser != null) {
// 用户信息不为空，则将其转换为PersonInfo
User user = (User) objectUser;
// 对user进行判断userId和角色类型
if (user != null && user.getUserId()> 0) {
if (user.getRole().getRoleId()==1 || user.getRole().getRoleId()==3) {
// 如果 <SUF>
return true;
}else {
System.out.println("无权限");
return false;
}
}
}
// 不满足验证，则直接跳转到登录页面
response.sendRedirect(request.getContextPath());
return false;
}
}
| true |
8856_4 | package com.loubii.account.util;
/**
* Created by luo on 2016/4/29.
* 银行卡帮助类，检验银行卡是否正确及获取银行卡归属地
*/
public class BankCardUtil {
/*
当你输入信用卡号码的时候，有没有担心输错了而造成损失呢？其实可以不必这么担心，
因为并不是一个随便的信用卡号码都是合法的，它必须通过Luhn算法来验证通过。
该校验的过程：
1、从卡号最后一位数字开始，逆向将奇数位(1、3、5等等)相加。
2、从卡号最后一位数字开始，逆向将偶数位数字，先乘以2（如果乘积为两位数，则将其减去9），再求和。
3、将奇数位总和加上偶数位总和，结果应该可以被10整除。
例如，卡号是：5432123456788881
则奇数、偶数位（用红色标出）分布：5432123456788881
奇数位和=35
偶数位乘以2（有些要减去9）的结果：1 6 2 6 1 5 7 7，求和=35。
最后35+35=70 可以被10整除，认定校验通过。
请编写一个程序，从键盘输入卡号，然后判断是否校验通过。通过显示：“成功”，否则显示“失败”。
比如，用户输入：356827027232780
程序输出：成功
*/
/**
* 校验银行卡卡号
*
* @param cardId
* @return
*/
public static boolean checkBankCard(String cardId) {
char bit = getBankCardCheckCode(cardId.substring(0, cardId.length() - 1));
if (bit == 'N') {
return false;
}
return cardId.charAt(cardId.length() - 1) == bit;
}
/**
* 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位
*
* @param nonCheckCodeCardId
* @return
*/
public static char getBankCardCheckCode(String nonCheckCodeCardId) {
if (nonCheckCodeCardId == null || nonCheckCodeCardId.trim().length() == 0
|| !nonCheckCodeCardId.matches("\\d+")) {
//如果传的不是数据返回N
return 'N';
}
char[] chs = nonCheckCodeCardId.trim().toCharArray();
int luhmSum = 0;
for (int i = chs.length - 1, j = 0; i >= 0; i--, j++) {
int k = chs[i] - '0';
if (j % 2 == 0) {
k *= 2;
k = k / 10 + k % 10;
}
luhmSum += k;
}
return (luhmSum % 10 == 0) ? '0' : (char) ((10 - luhmSum % 10) + '0');
}
// 银行卡是由”发卡行标识代码 + 自定义 + 校验码 “等部分组成的
// BIN号
//银联标准卡与以往发行的银行卡最直接的区别就是其卡号前6位数字的不同。
//银行卡卡号的前6位是用来表示发卡银行或机构的，称为“发卡行识别码”(Bank Identification Number，缩写为“BIN”)。
//银联标准卡是由国内各家商业银行(含邮储、信用社)共同发行、符合银联业务规范和技术标准、卡正面右下角带有“银联”标识(目前，新发行的银联标准卡一定带有国际化的银联新标识，新发的非银联标准卡使用旧的联网通用银联标识)、
//卡号前6位为622126至622925之一的银行卡，是中国银行卡产业共有的民族品牌。
// "发卡行.卡种名称",
// 查找方法,二分查找法
public static int binarySearch(int[] srcArray, int des) {
int low = 0;
int high = srcArray.length;
while (low < high) {
if (des == srcArray[low]) {
return low;
}
low++;
}
return -1;
}
}
| LouBii/OneAccount | account/src/main/java/com/loubii/account/util/BankCardUtil.java | 1,143 | //如果传的不是数据返回N | line_comment | zh-cn | package com.loubii.account.util;
/**
* Created by luo on 2016/4/29.
* 银行卡帮助类，检验银行卡是否正确及获取银行卡归属地
*/
public class BankCardUtil {
/*
当你输入信用卡号码的时候，有没有担心输错了而造成损失呢？其实可以不必这么担心，
因为并不是一个随便的信用卡号码都是合法的，它必须通过Luhn算法来验证通过。
该校验的过程：
1、从卡号最后一位数字开始，逆向将奇数位(1、3、5等等)相加。
2、从卡号最后一位数字开始，逆向将偶数位数字，先乘以2（如果乘积为两位数，则将其减去9），再求和。
3、将奇数位总和加上偶数位总和，结果应该可以被10整除。
例如，卡号是：5432123456788881
则奇数、偶数位（用红色标出）分布：5432123456788881
奇数位和=35
偶数位乘以2（有些要减去9）的结果：1 6 2 6 1 5 7 7，求和=35。
最后35+35=70 可以被10整除，认定校验通过。
请编写一个程序，从键盘输入卡号，然后判断是否校验通过。通过显示：“成功”，否则显示“失败”。
比如，用户输入：356827027232780
程序输出：成功
*/
/**
* 校验银行卡卡号
*
* @param cardId
* @return
*/
public static boolean checkBankCard(String cardId) {
char bit = getBankCardCheckCode(cardId.substring(0, cardId.length() - 1));
if (bit == 'N') {
return false;
}
return cardId.charAt(cardId.length() - 1) == bit;
}
/**
* 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位
*
* @param nonCheckCodeCardId
* @return
*/
public static char getBankCardCheckCode(String nonCheckCodeCardId) {
if (nonCheckCodeCardId == null || nonCheckCodeCardId.trim().length() == 0
|| !nonCheckCodeCardId.matches("\\d+")) {
//如果 <SUF>
return 'N';
}
char[] chs = nonCheckCodeCardId.trim().toCharArray();
int luhmSum = 0;
for (int i = chs.length - 1, j = 0; i >= 0; i--, j++) {
int k = chs[i] - '0';
if (j % 2 == 0) {
k *= 2;
k = k / 10 + k % 10;
}
luhmSum += k;
}
return (luhmSum % 10 == 0) ? '0' : (char) ((10 - luhmSum % 10) + '0');
}
// 银行卡是由”发卡行标识代码 + 自定义 + 校验码 “等部分组成的
// BIN号
//银联标准卡与以往发行的银行卡最直接的区别就是其卡号前6位数字的不同。
//银行卡卡号的前6位是用来表示发卡银行或机构的，称为“发卡行识别码”(Bank Identification Number，缩写为“BIN”)。
//银联标准卡是由国内各家商业银行(含邮储、信用社)共同发行、符合银联业务规范和技术标准、卡正面右下角带有“银联”标识(目前，新发行的银联标准卡一定带有国际化的银联新标识，新发的非银联标准卡使用旧的联网通用银联标识)、
//卡号前6位为622126至622925之一的银行卡，是中国银行卡产业共有的民族品牌。
// "发卡行.卡种名称",
// 查找方法,二分查找法
public static int binarySearch(int[] srcArray, int des) {
int low = 0;
int high = srcArray.length;
while (low < high) {
if (des == srcArray[low]) {
return low;
}
low++;
}
return -1;
}
}
| true |
48244_0 | package model;
/***
* 检查点实体类
*/
public class CheckPoint {
private String element_info;//暂时没有用
private String operate_type; //检查点方法，现在支持getValue,默认是查找,可自由拓展
private String find_type;//暂时无用
private String text; //文本框内容
public String getElement_info() {
return element_info;
}
public void setElement_info(String element_info) {
this.element_info = element_info;
}
public void setOperate_type(String operate_type) {
this.operate_type = operate_type;
}
public void setFind_type(String find_type) {
this.find_type = find_type;
}
public void setText(String text) {
this.text = text;
}
public String getOperate_type() {
return operate_type;
}
public String getFind_type() {
return find_type;
}
public String getText() {
return text;
}
}
| Louis-me/selenium_java | src/main/java/model/CheckPoint.java | 247 | /***
* 检查点实体类
*/ | block_comment | zh-cn | package model;
/***
* 检查点 <SUF>*/
public class CheckPoint {
private String element_info;//暂时没有用
private String operate_type; //检查点方法，现在支持getValue,默认是查找,可自由拓展
private String find_type;//暂时无用
private String text; //文本框内容
public String getElement_info() {
return element_info;
}
public void setElement_info(String element_info) {
this.element_info = element_info;
}
public void setOperate_type(String operate_type) {
this.operate_type = operate_type;
}
public void setFind_type(String find_type) {
this.find_type = find_type;
}
public void setText(String text) {
this.text = text;
}
public String getOperate_type() {
return operate_type;
}
public String getFind_type() {
return find_type;
}
public String getText() {
return text;
}
}
| true |
7359_23 | /* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.bpmn.behavior;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.delegate.Expression;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.Condition;
import org.activiti.engine.impl.bpmn.helper.SkipExpressionUtil;
import org.activiti.engine.impl.bpmn.parser.BpmnParse;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.JobEntity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.delegate.ActivityExecution;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.runtime.InterpretableExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helper class for implementing BPMN 2.0 activities, offering convenience
* methods specific to BPMN 2.0.
*
* This class can be used by inheritance or aggregation.
*
* @author Joram Barrez
*/
public class BpmnActivityBehavior implements Serializable {
private static final long serialVersionUID = 1L;
private static Logger log = LoggerFactory.getLogger(BpmnActivityBehavior.class);
/**
* Performs the default outgoing BPMN 2.0 behavior, which is having parallel
* paths of executions for the outgoing sequence flow.
*
* More precisely: every sequence flow that has a condition which evaluates to
* true (or which doesn't have a condition), is selected for continuation of
* the process instance. If multiple sequencer flow are selected, multiple,
* parallel paths of executions are created.
*/
public void performDefaultOutgoingBehavior(ActivityExecution activityExecution) {
//判断 获取的 activity 是不是 IntermediateCatchEventActivityBehavior 对象
ActivityImpl activity = (ActivityImpl) activityExecution.getActivity();
if (!(activity.getActivityBehavior() instanceof IntermediateCatchEventActivityBehavior)) {
//如果是 然后调用 dispatchJobCanceledEvents() 转发 JOB_CANCELDED 事件
dispatchJobCanceledEvents(activityExecution);
}
//开始真正执行活动行为类
performOutgoingBehavior(activityExecution, true, false, null);
}
/**
* Performs the default outgoing BPMN 2.0 behavior (@see
* {@link #performDefaultOutgoingBehavior(ActivityExecution)}), but without
* checking the conditions on the outgoing sequence flow.
*
* This means that every outgoing sequence flow is selected for continuing the
* process instance, regardless of having a condition or not. In case of
* multiple outgoing sequence flow, multiple parallel paths of executions will
* be created.
*/
public void performIgnoreConditionsOutgoingBehavior(ActivityExecution activityExecution) {
performOutgoingBehavior(activityExecution, false, false, null);
}
/**
* dispatch job canceled event for job associated with given execution entity
* @param activityExecution
*/
protected void dispatchJobCanceledEvents(ActivityExecution activityExecution) {
if (activityExecution instanceof ExecutionEntity) {
List<JobEntity> jobs = ((ExecutionEntity) activityExecution).getJobs();
for (JobEntity job: jobs) {
if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
ActivitiEventBuilder.createEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
}
/**
* Actual implementation of leaving an activity.
*
* @param execution
* The current execution context
* @param checkConditions
* Whether or not to check conditions before determining whether or
* not to take a transition.
* @param throwExceptionIfExecutionStuck
* If true, an {@link ActivitiException} will be thrown in case no
* transition could be found to leave the activity.
*
*
*/
protected void performOutgoingBehavior(ActivityExecution execution,
boolean checkConditions, boolean throwExceptionIfExecutionStuck, List<ActivityExecution> reusableExecutions) {
if (log.isDebugEnabled()) {
log.debug("Leaving activity '{}'", execution.getActivity().getId());
}
//获取default 属性值
String defaultSequenceFlow = (String) execution.getActivity().getProperty("default");
List<PvmTransition> transitionsToTake = new ArrayList<PvmTransition>();
//得到所有的出现信息 使用 outgoingTransitions 存储
List<PvmTransition> outgoingTransitions = execution.getActivity().getOutgoingTransitions();
//遍历所有的连线集合
for (PvmTransition outgoingTransition : outgoingTransitions) {
Expression skipExpression = outgoingTransition.getSkipExpression();
/*
* 判断连线是否配置了 skipExpression
* 委托 SkipExpressionUtil 表达式是否存在,
* 如果存在 继续验证表达式是否为true
* 如果是 则将其 添加到 transitionToTake 集合
*
* 如果没有配置 skipExpression
* 如果 defaultSequenceFlow 为null 或者 该变量不存在 outgoingTransitions集合中
* 获取 outgoingTransitions对象中的 condition 属性 并且使用 condition 变量进行表示
*
* */
if (!SkipExpressionUtil.isSkipExpressionEnabled(execution, skipExpression)) {
if (defaultSequenceFlow == null || !outgoingTransition.getId().equals(defaultSequenceFlow)) {
Condition condition = (Condition) outgoingTransition.getProperty(BpmnParse.PROPERTYNAME_CONDITION);
/*
* 如果 condition为null 或者 checkConditions fasle 或者条件 表达式计算之后验证通过
* */
if (condition == null || !checkConditions || condition.evaluate(outgoingTransition.getId(), execution)) {
/*
将outgoingTransition 添加到集合 中
也即Activiti 节点本身就支持并行性操作,
例如 为开始节点配置3个出线
而3个连线 都没有配置任何表达式,
则流程实例运转的过程 都会途径这三个 连线
*/
transitionsToTake.add(outgoingTransition);
}
}
} else if (SkipExpressionUtil.shouldSkipFlowElement(execution, skipExpression)){
transitionsToTake.add(outgoingTransition);
}
}
/*
* 如果 此集合 只存在一个元素 则执行 execution.take()
* */
if (transitionsToTake.size() == 1) {
execution.take(transitionsToTake.get(0));
/*
* 如果存在多个元素
* 设置 ExecutionEntity 对象中的 siActive() 属性值为fasle 然后执行 takeAll()
* */
} else if (transitionsToTake.size() >= 1) {
execution.inactivate();
if (reusableExecutions == null || reusableExecutions.isEmpty()) {
execution.takeAll(transitionsToTake, Arrays.asList(execution));
} else {
execution.takeAll(transitionsToTake, reusableExecutions);
}
} else {
//判断 defaultSequenceFlow 默认连线是否为空,
if (defaultSequenceFlow != null) {
//获取该连线 对应的 PVM 对象 并且使用 defaultTransition 变量存储
PvmTransition defaultTransition = execution.getActivity().findOutgoingTransition(defaultSequenceFlow);
if (defaultTransition != null) {
//执行 take ,否则报错
execution.take(defaultTransition);
} else {
throw new ActivitiException("Default sequence flow '" + defaultSequenceFlow + "' could not be not found");
}
}
// 查找当前节点是否配置了 isForCompensation 补偿
else {
Object isForCompensation = execution.getActivity().getProperty(BpmnParse.PROPERTYNAME_IS_FOR_COMPENSATION);
//如果 存在 并且为true
if(isForCompensation != null && (Boolean) isForCompensation) {
if (execution instanceof ExecutionEntity) {
Context.getCommandContext().getHistoryManager().recordActivityEnd((ExecutionEntity) execution);
}
InterpretableExecution parentExecution = (InterpretableExecution) execution.getParent();
((InterpretableExecution)execution).remove();
//使用发射信号方式完成该活动节点
parentExecution.signal("compensationDone", null);
}
//如果 不存在, 但是该值为fasle 直接结束当前的流程实例
else {
//
if (log.isDebugEnabled()) {
log.debug("No outgoing sequence flow found for {}. Ending execution.", execution.getActivity().getId());
}
execution.end();
if (throwExceptionIfExecutionStuck) {
throw new ActivitiException("No outgoing sequence flow of the inclusive gateway '" + execution.getActivity().getId()
+ "' could be selected for continuing the process");
}
}
}
}
}
}
| LoveMyOrange/ActivitiSourceCode | modules/activiti-engine/src/main/java/org/activiti/engine/impl/bpmn/behavior/BpmnActivityBehavior.java | 2,178 | //如果 不存在, 但是该值为fasle 直接结束当前的流程实例 | line_comment | zh-cn | /* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.bpmn.behavior;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.delegate.Expression;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.Condition;
import org.activiti.engine.impl.bpmn.helper.SkipExpressionUtil;
import org.activiti.engine.impl.bpmn.parser.BpmnParse;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.JobEntity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.delegate.ActivityExecution;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.runtime.InterpretableExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helper class for implementing BPMN 2.0 activities, offering convenience
* methods specific to BPMN 2.0.
*
* This class can be used by inheritance or aggregation.
*
* @author Joram Barrez
*/
public class BpmnActivityBehavior implements Serializable {
private static final long serialVersionUID = 1L;
private static Logger log = LoggerFactory.getLogger(BpmnActivityBehavior.class);
/**
* Performs the default outgoing BPMN 2.0 behavior, which is having parallel
* paths of executions for the outgoing sequence flow.
*
* More precisely: every sequence flow that has a condition which evaluates to
* true (or which doesn't have a condition), is selected for continuation of
* the process instance. If multiple sequencer flow are selected, multiple,
* parallel paths of executions are created.
*/
public void performDefaultOutgoingBehavior(ActivityExecution activityExecution) {
//判断 获取的 activity 是不是 IntermediateCatchEventActivityBehavior 对象
ActivityImpl activity = (ActivityImpl) activityExecution.getActivity();
if (!(activity.getActivityBehavior() instanceof IntermediateCatchEventActivityBehavior)) {
//如果是 然后调用 dispatchJobCanceledEvents() 转发 JOB_CANCELDED 事件
dispatchJobCanceledEvents(activityExecution);
}
//开始真正执行活动行为类
performOutgoingBehavior(activityExecution, true, false, null);
}
/**
* Performs the default outgoing BPMN 2.0 behavior (@see
* {@link #performDefaultOutgoingBehavior(ActivityExecution)}), but without
* checking the conditions on the outgoing sequence flow.
*
* This means that every outgoing sequence flow is selected for continuing the
* process instance, regardless of having a condition or not. In case of
* multiple outgoing sequence flow, multiple parallel paths of executions will
* be created.
*/
public void performIgnoreConditionsOutgoingBehavior(ActivityExecution activityExecution) {
performOutgoingBehavior(activityExecution, false, false, null);
}
/**
* dispatch job canceled event for job associated with given execution entity
* @param activityExecution
*/
protected void dispatchJobCanceledEvents(ActivityExecution activityExecution) {
if (activityExecution instanceof ExecutionEntity) {
List<JobEntity> jobs = ((ExecutionEntity) activityExecution).getJobs();
for (JobEntity job: jobs) {
if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
ActivitiEventBuilder.createEntityEvent(ActivitiEventType.JOB_CANCELED, job));
}
}
}
}
/**
* Actual implementation of leaving an activity.
*
* @param execution
* The current execution context
* @param checkConditions
* Whether or not to check conditions before determining whether or
* not to take a transition.
* @param throwExceptionIfExecutionStuck
* If true, an {@link ActivitiException} will be thrown in case no
* transition could be found to leave the activity.
*
*
*/
protected void performOutgoingBehavior(ActivityExecution execution,
boolean checkConditions, boolean throwExceptionIfExecutionStuck, List<ActivityExecution> reusableExecutions) {
if (log.isDebugEnabled()) {
log.debug("Leaving activity '{}'", execution.getActivity().getId());
}
//获取default 属性值
String defaultSequenceFlow = (String) execution.getActivity().getProperty("default");
List<PvmTransition> transitionsToTake = new ArrayList<PvmTransition>();
//得到所有的出现信息 使用 outgoingTransitions 存储
List<PvmTransition> outgoingTransitions = execution.getActivity().getOutgoingTransitions();
//遍历所有的连线集合
for (PvmTransition outgoingTransition : outgoingTransitions) {
Expression skipExpression = outgoingTransition.getSkipExpression();
/*
* 判断连线是否配置了 skipExpression
* 委托 SkipExpressionUtil 表达式是否存在,
* 如果存在 继续验证表达式是否为true
* 如果是 则将其 添加到 transitionToTake 集合
*
* 如果没有配置 skipExpression
* 如果 defaultSequenceFlow 为null 或者 该变量不存在 outgoingTransitions集合中
* 获取 outgoingTransitions对象中的 condition 属性 并且使用 condition 变量进行表示
*
* */
if (!SkipExpressionUtil.isSkipExpressionEnabled(execution, skipExpression)) {
if (defaultSequenceFlow == null || !outgoingTransition.getId().equals(defaultSequenceFlow)) {
Condition condition = (Condition) outgoingTransition.getProperty(BpmnParse.PROPERTYNAME_CONDITION);
/*
* 如果 condition为null 或者 checkConditions fasle 或者条件 表达式计算之后验证通过
* */
if (condition == null || !checkConditions || condition.evaluate(outgoingTransition.getId(), execution)) {
/*
将outgoingTransition 添加到集合 中
也即Activiti 节点本身就支持并行性操作,
例如 为开始节点配置3个出线
而3个连线 都没有配置任何表达式,
则流程实例运转的过程 都会途径这三个 连线
*/
transitionsToTake.add(outgoingTransition);
}
}
} else if (SkipExpressionUtil.shouldSkipFlowElement(execution, skipExpression)){
transitionsToTake.add(outgoingTransition);
}
}
/*
* 如果 此集合 只存在一个元素 则执行 execution.take()
* */
if (transitionsToTake.size() == 1) {
execution.take(transitionsToTake.get(0));
/*
* 如果存在多个元素
* 设置 ExecutionEntity 对象中的 siActive() 属性值为fasle 然后执行 takeAll()
* */
} else if (transitionsToTake.size() >= 1) {
execution.inactivate();
if (reusableExecutions == null || reusableExecutions.isEmpty()) {
execution.takeAll(transitionsToTake, Arrays.asList(execution));
} else {
execution.takeAll(transitionsToTake, reusableExecutions);
}
} else {
//判断 defaultSequenceFlow 默认连线是否为空,
if (defaultSequenceFlow != null) {
//获取该连线 对应的 PVM 对象 并且使用 defaultTransition 变量存储
PvmTransition defaultTransition = execution.getActivity().findOutgoingTransition(defaultSequenceFlow);
if (defaultTransition != null) {
//执行 take ,否则报错
execution.take(defaultTransition);
} else {
throw new ActivitiException("Default sequence flow '" + defaultSequenceFlow + "' could not be not found");
}
}
// 查找当前节点是否配置了 isForCompensation 补偿
else {
Object isForCompensation = execution.getActivity().getProperty(BpmnParse.PROPERTYNAME_IS_FOR_COMPENSATION);
//如果 存在 并且为true
if(isForCompensation != null && (Boolean) isForCompensation) {
if (execution instanceof ExecutionEntity) {
Context.getCommandContext().getHistoryManager().recordActivityEnd((ExecutionEntity) execution);
}
InterpretableExecution parentExecution = (InterpretableExecution) execution.getParent();
((InterpretableExecution)execution).remove();
//使用发射信号方式完成该活动节点
parentExecution.signal("compensationDone", null);
}
//如果 <SUF>
else {
//
if (log.isDebugEnabled()) {
log.debug("No outgoing sequence flow found for {}. Ending execution.", execution.getActivity().getId());
}
execution.end();
if (throwExceptionIfExecutionStuck) {
throw new ActivitiException("No outgoing sequence flow of the inclusive gateway '" + execution.getActivity().getId()
+ "' could be selected for continuing the process");
}
}
}
}
}
}
| true |
38816_31 | package cn.iocoder.yudao.module.promotion.api.price.dto;
import cn.iocoder.yudao.module.promotion.enums.common.PromotionLevelEnum;
import cn.iocoder.yudao.module.promotion.enums.common.PromotionTypeEnum;
import lombok.Data;
import java.util.List;
/**
* 价格计算 Response DTO
*
* 整体设计，参考 taobao 的技术文档：
* 1. <a href="https://developer.alibaba.com/docs/doc.htm?treeId=1&articleId=1029&docType=1">订单管理</a>
* 2. <a href="https://open.taobao.com/docV3.htm?docId=108471&docType=1">常用订单金额说明</a>
*
* 举个例子：<a href="https://img.alicdn.com/top/i1/LB1mALAi4HI8KJjy1zbXXaxdpXa">订单图</a>
* 输入：
* 1. 订单实付： trade.payment = 198.00；订单邮费：5 元；
* 2. 商品级优惠 圣诞价: 省 29.00 元 和 圣诞价:省 150.00 元； 订单级优惠，圣诞 2:省 5.00 元；
* 分摊：
* 1. 商品 1：原价 108 元，优惠 29 元，子订单实付 79 元，分摊主订单优惠 1.99 元；
* 2. 商品 2：原价 269 元，优惠 150 元，子订单实付 119 元，分摊主订单优惠 3.01 元；
*
* @author 芋道源码
*/
@Data
public class PriceCalculateRespDTO {
/**
* 订单
*/
private Order order;
/**
* 营销活动数组
*
* 只对应 {@link Order#items} 商品匹配的活动
*/
private List<Promotion> promotions;
/**
* 订单
*/
@Data
public static class Order {
/**
* 商品原价（总），单位：分
*
* 基于 {@link OrderItem#getOriginalPrice()} 求和
*
* 对应 taobao 的 trade.total_fee 字段
*/
private Integer originalPrice;
/**
* 订单原价（总），单位：分
*
* 基于 {@link OrderItem#getPayPrice()} 求和
* 和 {@link #originalPrice} 的差异：去除商品级优惠
*/
private Integer orderPrice;
/**
* 订单优惠（总），单位：分
*
* 订单级优惠：对主订单的优惠，常见如：订单满 200 元减 10 元；订单满 80 包邮。
*
* 对应 taobao 的 order.discount_fee 字段
*/
private Integer discountPrice;
/**
* 优惠劵减免金额（总），单位：分
*
* 对应 taobao 的 trade.coupon_fee 字段
*/
private Integer couponPrice;
/**
* 积分减免金额（总），单位：分
*
* 对应 taobao 的 trade.point_fee 字段
*/
private Integer pointPrice;
/**
* 运费金额，单位：分
*/
private Integer deliveryPrice;
/**
* 最终购买金额（总），单位：分
*
* = {@link OrderItem#getPayPrice()} 求和
* - {@link #couponPrice}
* - {@link #pointPrice}
* + {@link #deliveryPrice}
* - {@link #discountPrice}
*/
private Integer payPrice;
/**
* 商品 SKU 数组
*/
private List<OrderItem> items;
// ========== 营销基本信息 ==========
/**
* 优惠劵编号
*/
private Long couponId;
}
/**
* 订单商品 SKU
*/
@Data
public static class OrderItem {
/**
* SPU 编号
*/
private Long spuId;
/**
* SKU 编号
*/
private Long skuId;
/**
* 购买数量
*/
private Integer count;
/**
* 商品原价（总），单位：分
*
* = {@link #originalUnitPrice} * {@link #getCount()}
*/
private Integer originalPrice;
/**
* 商品原价（单），单位：分
*
* 对应 ProductSkuDO 的 price 字段
* 对应 taobao 的 order.price 字段
*/
private Integer originalUnitPrice;
/**
* 商品优惠（总），单位：分
*
* 商品级优惠：对单个商品的，常见如：商品原价的 8 折；商品原价的减 50 元
*
* 对应 taobao 的 order.discount_fee 字段
*/
private Integer discountPrice;
/**
* 子订单实付金额，不算主订单分摊金额，单位：分
*
* = {@link #originalPrice}
* - {@link #discountPrice}
*
* 对应 taobao 的 order.payment 字段
*/
private Integer payPrice;
/**
* 子订单分摊金额（总），单位：分
* 需要分摊 {@link Order#discountPrice}、{@link Order#couponPrice}、{@link Order#pointPrice}
*
* 对应 taobao 的 order.part_mjz_discount 字段
* 淘宝说明：子订单分摊优惠基础逻辑：一般正常优惠券和满减优惠按照子订单的金额进行分摊，特殊情况如果优惠券是指定商品使用的，只会分摊到对应商品子订单上不分摊。
*/
private Integer orderPartPrice;
/**
* 分摊后子订单实付金额（总），单位：分
*
* = {@link #payPrice}
* - {@link #orderPartPrice}
*
* 对应 taobao 的 divide_order_fee 字段
*/
private Integer orderDividePrice;
}
/**
* 营销明细
*/
@Data
public static class Promotion {
/**
* 营销编号
*
* 例如说：营销活动的编号、优惠劵的编号
*/
private Long id;
/**
* 营销名字
*/
private String name;
/**
* 营销类型
*
* 枚举 {@link PromotionTypeEnum}
*/
private Integer type;
/**
* 营销级别
*
* 枚举 {@link PromotionLevelEnum}
*/
private Integer level;
/**
* 计算时的原价（总），单位：分
*/
private Integer originalPrice;
/**
* 计算时的优惠（总），单位：分
*/
private Integer discountPrice;
/**
* 匹配的商品 SKU 数组
*/
private List<PromotionItem> items;
// ========== 匹配情况 ==========
/**
* 是否满足优惠条件
*/
private Boolean meet;
/**
* 满足条件的提示
*
* 如果 {@link #meet} = true 满足，则提示“圣诞价:省 150.00 元”
* 如果 {@link #meet} = false 不满足，则提示“购满 85 元，可减 40 元”
*/
private String meetTip;
}
/**
* 营销匹配的商品 SKU
*/
@Data
public static class PromotionItem {
/**
* 商品 SKU 编号
*/
private Long skuId;
/**
* 计算时的原价（总），单位：分
*/
private Integer originalPrice;
/**
* 计算时的优惠（总），单位：分
*/
private Integer discountPrice;
}
}
| LoveMyOrange/ding-flowable-vue2-enhance | YuDao/Camunda/ruoyi-vue-pro/yudao-module-mall/yudao-module-promotion-api/src/main/java/cn/iocoder/yudao/module/promotion/api/price/dto/PriceCalculateRespDTO.java | 1,928 | /**
* 匹配的商品 SKU 数组
*/ | block_comment | zh-cn | package cn.iocoder.yudao.module.promotion.api.price.dto;
import cn.iocoder.yudao.module.promotion.enums.common.PromotionLevelEnum;
import cn.iocoder.yudao.module.promotion.enums.common.PromotionTypeEnum;
import lombok.Data;
import java.util.List;
/**
* 价格计算 Response DTO
*
* 整体设计，参考 taobao 的技术文档：
* 1. <a href="https://developer.alibaba.com/docs/doc.htm?treeId=1&articleId=1029&docType=1">订单管理</a>
* 2. <a href="https://open.taobao.com/docV3.htm?docId=108471&docType=1">常用订单金额说明</a>
*
* 举个例子：<a href="https://img.alicdn.com/top/i1/LB1mALAi4HI8KJjy1zbXXaxdpXa">订单图</a>
* 输入：
* 1. 订单实付： trade.payment = 198.00；订单邮费：5 元；
* 2. 商品级优惠 圣诞价: 省 29.00 元 和 圣诞价:省 150.00 元； 订单级优惠，圣诞 2:省 5.00 元；
* 分摊：
* 1. 商品 1：原价 108 元，优惠 29 元，子订单实付 79 元，分摊主订单优惠 1.99 元；
* 2. 商品 2：原价 269 元，优惠 150 元，子订单实付 119 元，分摊主订单优惠 3.01 元；
*
* @author 芋道源码
*/
@Data
public class PriceCalculateRespDTO {
/**
* 订单
*/
private Order order;
/**
* 营销活动数组
*
* 只对应 {@link Order#items} 商品匹配的活动
*/
private List<Promotion> promotions;
/**
* 订单
*/
@Data
public static class Order {
/**
* 商品原价（总），单位：分
*
* 基于 {@link OrderItem#getOriginalPrice()} 求和
*
* 对应 taobao 的 trade.total_fee 字段
*/
private Integer originalPrice;
/**
* 订单原价（总），单位：分
*
* 基于 {@link OrderItem#getPayPrice()} 求和
* 和 {@link #originalPrice} 的差异：去除商品级优惠
*/
private Integer orderPrice;
/**
* 订单优惠（总），单位：分
*
* 订单级优惠：对主订单的优惠，常见如：订单满 200 元减 10 元；订单满 80 包邮。
*
* 对应 taobao 的 order.discount_fee 字段
*/
private Integer discountPrice;
/**
* 优惠劵减免金额（总），单位：分
*
* 对应 taobao 的 trade.coupon_fee 字段
*/
private Integer couponPrice;
/**
* 积分减免金额（总），单位：分
*
* 对应 taobao 的 trade.point_fee 字段
*/
private Integer pointPrice;
/**
* 运费金额，单位：分
*/
private Integer deliveryPrice;
/**
* 最终购买金额（总），单位：分
*
* = {@link OrderItem#getPayPrice()} 求和
* - {@link #couponPrice}
* - {@link #pointPrice}
* + {@link #deliveryPrice}
* - {@link #discountPrice}
*/
private Integer payPrice;
/**
* 商品 SKU 数组
*/
private List<OrderItem> items;
// ========== 营销基本信息 ==========
/**
* 优惠劵编号
*/
private Long couponId;
}
/**
* 订单商品 SKU
*/
@Data
public static class OrderItem {
/**
* SPU 编号
*/
private Long spuId;
/**
* SKU 编号
*/
private Long skuId;
/**
* 购买数量
*/
private Integer count;
/**
* 商品原价（总），单位：分
*
* = {@link #originalUnitPrice} * {@link #getCount()}
*/
private Integer originalPrice;
/**
* 商品原价（单），单位：分
*
* 对应 ProductSkuDO 的 price 字段
* 对应 taobao 的 order.price 字段
*/
private Integer originalUnitPrice;
/**
* 商品优惠（总），单位：分
*
* 商品级优惠：对单个商品的，常见如：商品原价的 8 折；商品原价的减 50 元
*
* 对应 taobao 的 order.discount_fee 字段
*/
private Integer discountPrice;
/**
* 子订单实付金额，不算主订单分摊金额，单位：分
*
* = {@link #originalPrice}
* - {@link #discountPrice}
*
* 对应 taobao 的 order.payment 字段
*/
private Integer payPrice;
/**
* 子订单分摊金额（总），单位：分
* 需要分摊 {@link Order#discountPrice}、{@link Order#couponPrice}、{@link Order#pointPrice}
*
* 对应 taobao 的 order.part_mjz_discount 字段
* 淘宝说明：子订单分摊优惠基础逻辑：一般正常优惠券和满减优惠按照子订单的金额进行分摊，特殊情况如果优惠券是指定商品使用的，只会分摊到对应商品子订单上不分摊。
*/
private Integer orderPartPrice;
/**
* 分摊后子订单实付金额（总），单位：分
*
* = {@link #payPrice}
* - {@link #orderPartPrice}
*
* 对应 taobao 的 divide_order_fee 字段
*/
private Integer orderDividePrice;
}
/**
* 营销明细
*/
@Data
public static class Promotion {
/**
* 营销编号
*
* 例如说：营销活动的编号、优惠劵的编号
*/
private Long id;
/**
* 营销名字
*/
private String name;
/**
* 营销类型
*
* 枚举 {@link PromotionTypeEnum}
*/
private Integer type;
/**
* 营销级别
*
* 枚举 {@link PromotionLevelEnum}
*/
private Integer level;
/**
* 计算时的原价（总），单位：分
*/
private Integer originalPrice;
/**
* 计算时的优惠（总），单位：分
*/
private Integer discountPrice;
/**
* 匹配的 <SUF>*/
private List<PromotionItem> items;
// ========== 匹配情况 ==========
/**
* 是否满足优惠条件
*/
private Boolean meet;
/**
* 满足条件的提示
*
* 如果 {@link #meet} = true 满足，则提示“圣诞价:省 150.00 元”
* 如果 {@link #meet} = false 不满足，则提示“购满 85 元，可减 40 元”
*/
private String meetTip;
}
/**
* 营销匹配的商品 SKU
*/
@Data
public static class PromotionItem {
/**
* 商品 SKU 编号
*/
private Long skuId;
/**
* 计算时的原价（总），单位：分
*/
private Integer originalPrice;
/**
* 计算时的优惠（总），单位：分
*/
private Integer discountPrice;
}
}
| true |
5064_11 | package com.book.manager.util.consts;
/**
* 常量
*/
public final class Constants {
/** 用户可解数量不足 */
public static final int USER_SIZE_NOT_ENOUGH = -101;
/** 图书库存数量不足 */
public static final int BOOK_SIZE_NOT_ENOUGH = -102;
/** 用户已借过该图书 */
public static final int BOOK_BORROWED = -201;
/** 是 */
public static final int YES = 0;
/** 否 */
public static final int NO = 1;
/** 一切正常 */
public static final int OK = 1;
/** 是 */
public static final String YES_STR = "是";
/** 否 */
public static final String NO_STR = "否";
/** 日期格式 */
public static final String DATE_FORMAT = "yyyy-MM-dd";
/** 学生 */
public static final int STUDENT = 0;
/** 教师 */
public static final int TEACHER = 1;
/** 其他 */
public static final int OTHER = 2;
/** 管理员 */
public static final int ADMIN = 3;
/** 身份 */
public static final String STU_STR = "学生";
public static final String TEA_STR = "教师";
public static final String OTHER_STR = "社会人士";
public static final String ADMIN_STR = "管理员";
}
| LovebuildJ/book-manager | src/main/java/com/book/manager/util/consts/Constants.java | 348 | /** 教师 */ | block_comment | zh-cn | package com.book.manager.util.consts;
/**
* 常量
*/
public final class Constants {
/** 用户可解数量不足 */
public static final int USER_SIZE_NOT_ENOUGH = -101;
/** 图书库存数量不足 */
public static final int BOOK_SIZE_NOT_ENOUGH = -102;
/** 用户已借过该图书 */
public static final int BOOK_BORROWED = -201;
/** 是 */
public static final int YES = 0;
/** 否 */
public static final int NO = 1;
/** 一切正常 */
public static final int OK = 1;
/** 是 */
public static final String YES_STR = "是";
/** 否 */
public static final String NO_STR = "否";
/** 日期格式 */
public static final String DATE_FORMAT = "yyyy-MM-dd";
/** 学生 */
public static final int STUDENT = 0;
/** 教师 <SUF>*/
public static final int TEACHER = 1;
/** 其他 */
public static final int OTHER = 2;
/** 管理员 */
public static final int ADMIN = 3;
/** 身份 */
public static final String STU_STR = "学生";
public static final String TEA_STR = "教师";
public static final String OTHER_STR = "社会人士";
public static final String ADMIN_STR = "管理员";
}
| false |
52864_2 | /*
*
* No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
*
* OpenAPI spec version: 1.0.0
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
package com.douyin.open.models;
import java.util.Objects;
import java.util.Arrays;
import com.douyin.open.models.PoiProductProductSpuAttributes1201;
import com.douyin.open.models.PoiProductProductSpuAttributes1209;
import com.douyin.open.models.PoiProductProductSpuAttributes1211;
import com.douyin.open.models.PoiProductProductSpuAttributes1212;
import com.douyin.open.models.PoiProductProductSpuAttributes1213;
import com.douyin.open.models.PoiProductProductSpuAttributes4101;
import com.douyin.open.models.PoiProductProductSpuAttributes90201;
import com.douyin.open.models.PoiProductProductSpuAttributes90205;
import com.douyin.open.models.PoiProductProductSpuAttributes9101;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import io.swagger.v3.oas.annotations.media.Schema;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
* SPU属性字段
*/
@Schema(description = "SPU属性字段")
@javax.annotation.Generated(value = "io.swagger.codegen.v3.generators.java.JavaClientCodegen", date = "2020-08-13T12:08:54.684786+08:00[Asia/Shanghai]")
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class PoiProductProductSpuAttributes {
@JsonProperty("1201")
private List<PoiProductProductSpuAttributes1201> _1201 = null;
@JsonProperty("1202")
private String _1202 = null;
@JsonProperty("1203")
private Integer _1203 = null;
@JsonProperty("1204")
private BigDecimal _1204 = null;
@JsonProperty("1205")
private String _1205 = null;
@JsonProperty("1206")
private List<String> _1206 = null;
@JsonProperty("1207")
private String _1207 = null;
@JsonProperty("1208")
private String _1208 = null;
@JsonProperty("1209")
private PoiProductProductSpuAttributes1209 _1209 = null;
@JsonProperty("1210")
private String _1210 = null;
@JsonProperty("1211")
private PoiProductProductSpuAttributes1211 _1211 = null;
@JsonProperty("1212")
private PoiProductProductSpuAttributes1212 _1212 = null;
@JsonProperty("1213")
private PoiProductProductSpuAttributes1213 _1213 = null;
/**
* 早餐; 0 - 无早餐; 1~9 - n份早餐; 10 - 多份早餐
*/
public enum _1214Enum {
NUMBER_0(0),
NUMBER_1(1),
NUMBER_2(2),
NUMBER_3(3),
NUMBER_4(4),
NUMBER_5(5),
NUMBER_6(6),
NUMBER_7(7),
NUMBER_8(8),
NUMBER_9(9),
NUMBER_10(10);
private Integer value;
_1214Enum(Integer value) {
this.value = value;
}
@JsonValue
public Integer getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static _1214Enum fromValue(String text) {
for (_1214Enum b : _1214Enum.values()) {
if (String.valueOf(b.value).equals(text)) {
return b;
}
}
return null;
}
} @JsonProperty("1214")
private _1214Enum _1214 = null;
@JsonProperty("90201")
private PoiProductProductSpuAttributes90201 _90201 = null;
/**
* 是否可退 1- 随时退，2-不可退, 3-有条件退
*/
public enum _90202Enum {
NUMBER_1(1),
NUMBER_2(2),
NUMBER_3(3);
private Integer value;
_90202Enum(Integer value) {
this.value = value;
}
@JsonValue
public Integer getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static _90202Enum fromValue(String text) {
for (_90202Enum b : _90202Enum.values()) {
if (String.valueOf(b.value).equals(text)) {
return b;
}
}
return null;
}
} @JsonProperty("90202")
private _90202Enum _90202 = null;
/**
* 取票信息 1-需要取票 2-无需取票
*/
public enum _90203Enum {
NUMBER_1(1),
NUMBER_2(2);
private Integer value;
_90203Enum(Integer value) {
this.value = value;
}
@JsonValue
public Integer getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static _90203Enum fromValue(String text) {
for (_90203Enum b : _90203Enum.values()) {
if (String.valueOf(b.value).equals(text)) {
return b;
}
}
return null;
}
} @JsonProperty("90203")
private _90203Enum _90203 = null;
@JsonProperty("90204")
private Integer _90204 = null;
@JsonProperty("90205")
private PoiProductProductSpuAttributes90205 _90205 = null;
@JsonProperty("4101")
private PoiProductProductSpuAttributes4101 _4101 = null;
@JsonProperty("9101")
private PoiProductProductSpuAttributes9101 _9101 = null;
public PoiProductProductSpuAttributes _1201(List<PoiProductProductSpuAttributes1201> _1201) {
this._1201 = _1201;
return this;
}
public PoiProductProductSpuAttributes add1201Item(PoiProductProductSpuAttributes1201 _1201Item) {
if (this._1201 == null) {
this._1201 = new ArrayList<>();
}
this._1201.add(_1201Item);
return this;
}
/**
* 设施列表
* @return _1201
**/
@Schema(example = "[{\"code\":\"1000\",\"name\":\"空调\"},{\"code\":\"1000\",\"name\":\"窗户\"},{\"code\":\"1000\",\"name\":\"独立卫浴\"}]", description = "设施列表")
public List<PoiProductProductSpuAttributes1201> get1201() {
return _1201;
}
public void set1201(List<PoiProductProductSpuAttributes1201> _1201) {
this._1201 = _1201;
}
public PoiProductProductSpuAttributes _1202(String _1202) {
this._1202 = _1202;
return this;
}
/**
* 床型名称
* @return _1202
**/
@Schema(example = "2*1.5米大床1张+2*1.2米单人床1张", description = "床型名称")
public String get1202() {
return _1202;
}
public void set1202(String _1202) {
this._1202 = _1202;
}
public PoiProductProductSpuAttributes _1203(Integer _1203) {
this._1203 = _1203;
return this;
}
/**
* 可住人数
* @return _1203
**/
@Schema(example = "3", description = "可住人数")
public Integer get1203() {
return _1203;
}
public void set1203(Integer _1203) {
this._1203 = _1203;
}
public PoiProductProductSpuAttributes _1204(BigDecimal _1204) {
this._1204 = _1204;
return this;
}
/**
* 面积(平方米)
* @return _1204
**/
@Schema(example = "28", description = "面积(平方米)")
public BigDecimal get1204() {
return _1204;
}
public void set1204(BigDecimal _1204) {
this._1204 = _1204;
}
public PoiProductProductSpuAttributes _1205(String _1205) {
this._1205 = _1205;
return this;
}
/**
* 房型封面图
* @return _1205
**/
@Schema(example = "https://static.dingdandao.com/6ecf79cc9c8aab0e7d8fcc56eaf95342", description = "房型封面图")
public String get1205() {
return _1205;
}
public void set1205(String _1205) {
this._1205 = _1205;
}
public PoiProductProductSpuAttributes _1206(List<String> _1206) {
this._1206 = _1206;
return this;
}
public PoiProductProductSpuAttributes add1206Item(String _1206Item) {
if (this._1206 == null) {
this._1206 = new ArrayList<>();
}
this._1206.add(_1206Item);
return this;
}
/**
* 房型相册
* @return _1206
**/
@Schema(example = "[\"https://static.dingdandao.com/6ecf79cc9c8aab0e7d8fcc56eaf95342\",\"https://static.dingdandao.com/486b7541a39b9ce9c14903a10f371856\",\"https://static.dingdandao.com/a99f3d43bdc5a70133d9e023adab2529\",\"https://static.dingdandao.com/e3ced877d4bcfde0f1c1eba0199d23a4\",\"https://static.dingdandao.com/cac43a12847c6bf9c25e8a9190d02b92\",\"https://static.dingdandao.com/aa8f29af38b78bba45b0337861c452b3\",\"https://static.dingdandao.com/7515de5f56b1458f9c9baad28a2162d8\"]", description = "房型相册")
public List<String> get1206() {
return _1206;
}
public void set1206(List<String> _1206) {
this._1206 = _1206;
}
public PoiProductProductSpuAttributes _1207(String _1207) {
this._1207 = _1207;
return this;
}
/**
* 房型简介
* @return _1207
**/
@Schema(example = "位置：二楼 朝南 （热门 特色：采光超好，床头即是窗边美景 朝阳大落地窗，超大露台浴缸 极具设计美感空间设计 配备：1.6*2米乳胶大床，1*1.6米定制儿童床 严选时尚家居用品，高端品牌床上用品 42寸智能电视,TOTO卫浴 适合人数：2大1小（不可加床）", description = "房型简介")
public String get1207() {
return _1207;
}
public void set1207(String _1207) {
this._1207 = _1207;
}
public PoiProductProductSpuAttributes _1208(String _1208) {
this._1208 = _1208;
return this;
}
/**
* 相关政策
* @return _1208
**/
@Schema(example = "==入住规则== 1、入住需登记住房人的身份信息；大门采用电子锁，凭房卡刷卡自主出入 2、入住时间为14:00-23:00，提前到店可寄存行李，23点后到店如无预约民宿接送，则可能会需要您自行办理入住 3、上海市室内全面禁烟，房间及楼层内请勿吸烟，按条例规定室内抽烟罚款200元/次。 4、23点-次日7点时间段入住/退房客人请保持安静，需自助办理入住或退房（我们为早起去迪士尼的客人配备可打包带走的早餐，欢迎您提前到店预约） 5、可代收快递；可寄存行李；可打印复印文件；可开具住宿发票 6、商业摄影200元/小时起（公共区域+1个房间）详询店内工作人员 7、为您提供加床服务，有榻榻米床垫或折叠小床供您选择，成人（超员）加床100元/晚（含早） ==儿童政策== 1m以下婴幼儿入住，免费赠送早餐、部分房型可提供婴儿床 1m-1.4m儿童入住，加早餐18元/位，使用现有床铺免费，加床50元/晚（含早） 1.4m以上青少年，加早餐25元/位，使用现有床铺免费，加床60元/晚（含早） ==宠物政策== 允许携带宠物入住，请勿将宠物带入餐厅/儿童娱乐区 视清洁情况可能会要求加收清洁费50元/晚", description = "相关政策")
public String get1208() {
return _1208;
}
public void set1208(String _1208) {
this._1208 = _1208;
}
public PoiProductProductSpuAttributes _1209(PoiProductProductSpuAttributes1209 _1209) {
this._1209 = _1209;
return this;
}
/**
* Get _1209
* @return _1209
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1209 get1209() {
return _1209;
}
public void set1209(PoiProductProductSpuAttributes1209 _1209) {
this._1209 = _1209;
}
public PoiProductProductSpuAttributes _1210(String _1210) {
this._1210 = _1210;
return this;
}
/**
* 景观
* @return _1210
**/
@Schema(example = "海滩景观", description = "景观")
public String get1210() {
return _1210;
}
public void set1210(String _1210) {
this._1210 = _1210;
}
public PoiProductProductSpuAttributes _1211(PoiProductProductSpuAttributes1211 _1211) {
this._1211 = _1211;
return this;
}
/**
* Get _1211
* @return _1211
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1211 get1211() {
return _1211;
}
public void set1211(PoiProductProductSpuAttributes1211 _1211) {
this._1211 = _1211;
}
public PoiProductProductSpuAttributes _1212(PoiProductProductSpuAttributes1212 _1212) {
this._1212 = _1212;
return this;
}
/**
* Get _1212
* @return _1212
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1212 get1212() {
return _1212;
}
public void set1212(PoiProductProductSpuAttributes1212 _1212) {
this._1212 = _1212;
}
public PoiProductProductSpuAttributes _1213(PoiProductProductSpuAttributes1213 _1213) {
this._1213 = _1213;
return this;
}
/**
* Get _1213
* @return _1213
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1213 get1213() {
return _1213;
}
public void set1213(PoiProductProductSpuAttributes1213 _1213) {
this._1213 = _1213;
}
public PoiProductProductSpuAttributes _1214(_1214Enum _1214) {
this._1214 = _1214;
return this;
}
/**
* 早餐; 0 - 无早餐; 1~9 - n份早餐; 10 - 多份早餐
* @return _1214
**/
@Schema(description = "早餐; 0 - 无早餐; 1~9 - n份早餐; 10 - 多份早餐")
public _1214Enum get1214() {
return _1214;
}
public void set1214(_1214Enum _1214) {
this._1214 = _1214;
}
public PoiProductProductSpuAttributes _90201(PoiProductProductSpuAttributes90201 _90201) {
this._90201 = _90201;
return this;
}
/**
* Get _90201
* @return _90201
**/
@Schema(description = "")
public PoiProductProductSpuAttributes90201 get90201() {
return _90201;
}
public void set90201(PoiProductProductSpuAttributes90201 _90201) {
this._90201 = _90201;
}
public PoiProductProductSpuAttributes _90202(_90202Enum _90202) {
this._90202 = _90202;
return this;
}
/**
* 是否可退 1- 随时退，2-不可退, 3-有条件退
* @return _90202
**/
@Schema(description = "是否可退 1- 随时退，2-不可退, 3-有条件退")
public _90202Enum get90202() {
return _90202;
}
public void set90202(_90202Enum _90202) {
this._90202 = _90202;
}
public PoiProductProductSpuAttributes _90203(_90203Enum _90203) {
this._90203 = _90203;
return this;
}
/**
* 取票信息 1-需要取票 2-无需取票
* @return _90203
**/
@Schema(description = "取票信息 1-需要取票 2-无需取票")
public _90203Enum get90203() {
return _90203;
}
public void set90203(_90203Enum _90203) {
this._90203 = _90203;
}
public PoiProductProductSpuAttributes _90204(Integer _90204) {
this._90204 = _90204;
return this;
}
/**
* 门票价格(展示最近7日最低价，精确到分)
* @return _90204
**/
@Schema(example = "16800", description = "门票价格(展示最近7日最低价，精确到分)")
public Integer get90204() {
return _90204;
}
public void set90204(Integer _90204) {
this._90204 = _90204;
}
public PoiProductProductSpuAttributes _90205(PoiProductProductSpuAttributes90205 _90205) {
this._90205 = _90205;
return this;
}
/**
* Get _90205
* @return _90205
**/
@Schema(description = "")
public PoiProductProductSpuAttributes90205 get90205() {
return _90205;
}
public void set90205(PoiProductProductSpuAttributes90205 _90205) {
this._90205 = _90205;
}
public PoiProductProductSpuAttributes _4101(PoiProductProductSpuAttributes4101 _4101) {
this._4101 = _4101;
return this;
}
/**
* Get _4101
* @return _4101
**/
@Schema(description = "")
public PoiProductProductSpuAttributes4101 get4101() {
return _4101;
}
public void set4101(PoiProductProductSpuAttributes4101 _4101) {
this._4101 = _4101;
}
public PoiProductProductSpuAttributes _9101(PoiProductProductSpuAttributes9101 _9101) {
this._9101 = _9101;
return this;
}
/**
* Get _9101
* @return _9101
**/
@Schema(description = "")
public PoiProductProductSpuAttributes9101 get9101() {
return _9101;
}
public void set9101(PoiProductProductSpuAttributes9101 _9101) {
this._9101 = _9101;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
PoiProductProductSpuAttributes spuAttributes = (PoiProductProductSpuAttributes) o;
return Objects.equals(this._1201, spuAttributes._1201) &&
Objects.equals(this._1202, spuAttributes._1202) &&
Objects.equals(this._1203, spuAttributes._1203) &&
Objects.equals(this._1204, spuAttributes._1204) &&
Objects.equals(this._1205, spuAttributes._1205) &&
Objects.equals(this._1206, spuAttributes._1206) &&
Objects.equals(this._1207, spuAttributes._1207) &&
Objects.equals(this._1208, spuAttributes._1208) &&
Objects.equals(this._1209, spuAttributes._1209) &&
Objects.equals(this._1210, spuAttributes._1210) &&
Objects.equals(this._1211, spuAttributes._1211) &&
Objects.equals(this._1212, spuAttributes._1212) &&
Objects.equals(this._1213, spuAttributes._1213) &&
Objects.equals(this._1214, spuAttributes._1214) &&
Objects.equals(this._90201, spuAttributes._90201) &&
Objects.equals(this._90202, spuAttributes._90202) &&
Objects.equals(this._90203, spuAttributes._90203) &&
Objects.equals(this._90204, spuAttributes._90204) &&
Objects.equals(this._90205, spuAttributes._90205) &&
Objects.equals(this._4101, spuAttributes._4101) &&
Objects.equals(this._9101, spuAttributes._9101);
}
@Override
public int hashCode() {
return Objects.hash(_1201, _1202, _1203, _1204, _1205, _1206, _1207, _1208, _1209, _1210, _1211, _1212, _1213, _1214, _90201, _90202, _90203, _90204, _90205, _4101, _9101);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class PoiProductProductSpuAttributes {\n");
sb.append(" _1201: ").append(toIndentedString(_1201)).append("\n");
sb.append(" _1202: ").append(toIndentedString(_1202)).append("\n");
sb.append(" _1203: ").append(toIndentedString(_1203)).append("\n");
sb.append(" _1204: ").append(toIndentedString(_1204)).append("\n");
sb.append(" _1205: ").append(toIndentedString(_1205)).append("\n");
sb.append(" _1206: ").append(toIndentedString(_1206)).append("\n");
sb.append(" _1207: ").append(toIndentedString(_1207)).append("\n");
sb.append(" _1208: ").append(toIndentedString(_1208)).append("\n");
sb.append(" _1209: ").append(toIndentedString(_1209)).append("\n");
sb.append(" _1210: ").append(toIndentedString(_1210)).append("\n");
sb.append(" _1211: ").append(toIndentedString(_1211)).append("\n");
sb.append(" _1212: ").append(toIndentedString(_1212)).append("\n");
sb.append(" _1213: ").append(toIndentedString(_1213)).append("\n");
sb.append(" _1214: ").append(toIndentedString(_1214)).append("\n");
sb.append(" _90201: ").append(toIndentedString(_90201)).append("\n");
sb.append(" _90202: ").append(toIndentedString(_90202)).append("\n");
sb.append(" _90203: ").append(toIndentedString(_90203)).append("\n");
sb.append(" _90204: ").append(toIndentedString(_90204)).append("\n");
sb.append(" _90205: ").append(toIndentedString(_90205)).append("\n");
sb.append(" _4101: ").append(toIndentedString(_4101)).append("\n");
sb.append(" _9101: ").append(toIndentedString(_9101)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
| LovebuildJ/douyin-open-api-sdk | official-sdk/src/main/java/com/douyin/open/models/PoiProductProductSpuAttributes.java | 7,526 | /**
* 早餐; 0 - 无早餐; 1~9 - n份早餐; 10 - 多份早餐
*/ | block_comment | zh-cn | /*
*
* No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
*
* OpenAPI spec version: 1.0.0
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*/
package com.douyin.open.models;
import java.util.Objects;
import java.util.Arrays;
import com.douyin.open.models.PoiProductProductSpuAttributes1201;
import com.douyin.open.models.PoiProductProductSpuAttributes1209;
import com.douyin.open.models.PoiProductProductSpuAttributes1211;
import com.douyin.open.models.PoiProductProductSpuAttributes1212;
import com.douyin.open.models.PoiProductProductSpuAttributes1213;
import com.douyin.open.models.PoiProductProductSpuAttributes4101;
import com.douyin.open.models.PoiProductProductSpuAttributes90201;
import com.douyin.open.models.PoiProductProductSpuAttributes90205;
import com.douyin.open.models.PoiProductProductSpuAttributes9101;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import io.swagger.v3.oas.annotations.media.Schema;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
* SPU属性字段
*/
@Schema(description = "SPU属性字段")
@javax.annotation.Generated(value = "io.swagger.codegen.v3.generators.java.JavaClientCodegen", date = "2020-08-13T12:08:54.684786+08:00[Asia/Shanghai]")
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class PoiProductProductSpuAttributes {
@JsonProperty("1201")
private List<PoiProductProductSpuAttributes1201> _1201 = null;
@JsonProperty("1202")
private String _1202 = null;
@JsonProperty("1203")
private Integer _1203 = null;
@JsonProperty("1204")
private BigDecimal _1204 = null;
@JsonProperty("1205")
private String _1205 = null;
@JsonProperty("1206")
private List<String> _1206 = null;
@JsonProperty("1207")
private String _1207 = null;
@JsonProperty("1208")
private String _1208 = null;
@JsonProperty("1209")
private PoiProductProductSpuAttributes1209 _1209 = null;
@JsonProperty("1210")
private String _1210 = null;
@JsonProperty("1211")
private PoiProductProductSpuAttributes1211 _1211 = null;
@JsonProperty("1212")
private PoiProductProductSpuAttributes1212 _1212 = null;
@JsonProperty("1213")
private PoiProductProductSpuAttributes1213 _1213 = null;
/**
* 早餐; <SUF>*/
public enum _1214Enum {
NUMBER_0(0),
NUMBER_1(1),
NUMBER_2(2),
NUMBER_3(3),
NUMBER_4(4),
NUMBER_5(5),
NUMBER_6(6),
NUMBER_7(7),
NUMBER_8(8),
NUMBER_9(9),
NUMBER_10(10);
private Integer value;
_1214Enum(Integer value) {
this.value = value;
}
@JsonValue
public Integer getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static _1214Enum fromValue(String text) {
for (_1214Enum b : _1214Enum.values()) {
if (String.valueOf(b.value).equals(text)) {
return b;
}
}
return null;
}
} @JsonProperty("1214")
private _1214Enum _1214 = null;
@JsonProperty("90201")
private PoiProductProductSpuAttributes90201 _90201 = null;
/**
* 是否可退 1- 随时退，2-不可退, 3-有条件退
*/
public enum _90202Enum {
NUMBER_1(1),
NUMBER_2(2),
NUMBER_3(3);
private Integer value;
_90202Enum(Integer value) {
this.value = value;
}
@JsonValue
public Integer getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static _90202Enum fromValue(String text) {
for (_90202Enum b : _90202Enum.values()) {
if (String.valueOf(b.value).equals(text)) {
return b;
}
}
return null;
}
} @JsonProperty("90202")
private _90202Enum _90202 = null;
/**
* 取票信息 1-需要取票 2-无需取票
*/
public enum _90203Enum {
NUMBER_1(1),
NUMBER_2(2);
private Integer value;
_90203Enum(Integer value) {
this.value = value;
}
@JsonValue
public Integer getValue() {
return value;
}
@Override
public String toString() {
return String.valueOf(value);
}
@JsonCreator
public static _90203Enum fromValue(String text) {
for (_90203Enum b : _90203Enum.values()) {
if (String.valueOf(b.value).equals(text)) {
return b;
}
}
return null;
}
} @JsonProperty("90203")
private _90203Enum _90203 = null;
@JsonProperty("90204")
private Integer _90204 = null;
@JsonProperty("90205")
private PoiProductProductSpuAttributes90205 _90205 = null;
@JsonProperty("4101")
private PoiProductProductSpuAttributes4101 _4101 = null;
@JsonProperty("9101")
private PoiProductProductSpuAttributes9101 _9101 = null;
public PoiProductProductSpuAttributes _1201(List<PoiProductProductSpuAttributes1201> _1201) {
this._1201 = _1201;
return this;
}
public PoiProductProductSpuAttributes add1201Item(PoiProductProductSpuAttributes1201 _1201Item) {
if (this._1201 == null) {
this._1201 = new ArrayList<>();
}
this._1201.add(_1201Item);
return this;
}
/**
* 设施列表
* @return _1201
**/
@Schema(example = "[{\"code\":\"1000\",\"name\":\"空调\"},{\"code\":\"1000\",\"name\":\"窗户\"},{\"code\":\"1000\",\"name\":\"独立卫浴\"}]", description = "设施列表")
public List<PoiProductProductSpuAttributes1201> get1201() {
return _1201;
}
public void set1201(List<PoiProductProductSpuAttributes1201> _1201) {
this._1201 = _1201;
}
public PoiProductProductSpuAttributes _1202(String _1202) {
this._1202 = _1202;
return this;
}
/**
* 床型名称
* @return _1202
**/
@Schema(example = "2*1.5米大床1张+2*1.2米单人床1张", description = "床型名称")
public String get1202() {
return _1202;
}
public void set1202(String _1202) {
this._1202 = _1202;
}
public PoiProductProductSpuAttributes _1203(Integer _1203) {
this._1203 = _1203;
return this;
}
/**
* 可住人数
* @return _1203
**/
@Schema(example = "3", description = "可住人数")
public Integer get1203() {
return _1203;
}
public void set1203(Integer _1203) {
this._1203 = _1203;
}
public PoiProductProductSpuAttributes _1204(BigDecimal _1204) {
this._1204 = _1204;
return this;
}
/**
* 面积(平方米)
* @return _1204
**/
@Schema(example = "28", description = "面积(平方米)")
public BigDecimal get1204() {
return _1204;
}
public void set1204(BigDecimal _1204) {
this._1204 = _1204;
}
public PoiProductProductSpuAttributes _1205(String _1205) {
this._1205 = _1205;
return this;
}
/**
* 房型封面图
* @return _1205
**/
@Schema(example = "https://static.dingdandao.com/6ecf79cc9c8aab0e7d8fcc56eaf95342", description = "房型封面图")
public String get1205() {
return _1205;
}
public void set1205(String _1205) {
this._1205 = _1205;
}
public PoiProductProductSpuAttributes _1206(List<String> _1206) {
this._1206 = _1206;
return this;
}
public PoiProductProductSpuAttributes add1206Item(String _1206Item) {
if (this._1206 == null) {
this._1206 = new ArrayList<>();
}
this._1206.add(_1206Item);
return this;
}
/**
* 房型相册
* @return _1206
**/
@Schema(example = "[\"https://static.dingdandao.com/6ecf79cc9c8aab0e7d8fcc56eaf95342\",\"https://static.dingdandao.com/486b7541a39b9ce9c14903a10f371856\",\"https://static.dingdandao.com/a99f3d43bdc5a70133d9e023adab2529\",\"https://static.dingdandao.com/e3ced877d4bcfde0f1c1eba0199d23a4\",\"https://static.dingdandao.com/cac43a12847c6bf9c25e8a9190d02b92\",\"https://static.dingdandao.com/aa8f29af38b78bba45b0337861c452b3\",\"https://static.dingdandao.com/7515de5f56b1458f9c9baad28a2162d8\"]", description = "房型相册")
public List<String> get1206() {
return _1206;
}
public void set1206(List<String> _1206) {
this._1206 = _1206;
}
public PoiProductProductSpuAttributes _1207(String _1207) {
this._1207 = _1207;
return this;
}
/**
* 房型简介
* @return _1207
**/
@Schema(example = "位置：二楼 朝南 （热门 特色：采光超好，床头即是窗边美景 朝阳大落地窗，超大露台浴缸 极具设计美感空间设计 配备：1.6*2米乳胶大床，1*1.6米定制儿童床 严选时尚家居用品，高端品牌床上用品 42寸智能电视,TOTO卫浴 适合人数：2大1小（不可加床）", description = "房型简介")
public String get1207() {
return _1207;
}
public void set1207(String _1207) {
this._1207 = _1207;
}
public PoiProductProductSpuAttributes _1208(String _1208) {
this._1208 = _1208;
return this;
}
/**
* 相关政策
* @return _1208
**/
@Schema(example = "==入住规则== 1、入住需登记住房人的身份信息；大门采用电子锁，凭房卡刷卡自主出入 2、入住时间为14:00-23:00，提前到店可寄存行李，23点后到店如无预约民宿接送，则可能会需要您自行办理入住 3、上海市室内全面禁烟，房间及楼层内请勿吸烟，按条例规定室内抽烟罚款200元/次。 4、23点-次日7点时间段入住/退房客人请保持安静，需自助办理入住或退房（我们为早起去迪士尼的客人配备可打包带走的早餐，欢迎您提前到店预约） 5、可代收快递；可寄存行李；可打印复印文件；可开具住宿发票 6、商业摄影200元/小时起（公共区域+1个房间）详询店内工作人员 7、为您提供加床服务，有榻榻米床垫或折叠小床供您选择，成人（超员）加床100元/晚（含早） ==儿童政策== 1m以下婴幼儿入住，免费赠送早餐、部分房型可提供婴儿床 1m-1.4m儿童入住，加早餐18元/位，使用现有床铺免费，加床50元/晚（含早） 1.4m以上青少年，加早餐25元/位，使用现有床铺免费，加床60元/晚（含早） ==宠物政策== 允许携带宠物入住，请勿将宠物带入餐厅/儿童娱乐区 视清洁情况可能会要求加收清洁费50元/晚", description = "相关政策")
public String get1208() {
return _1208;
}
public void set1208(String _1208) {
this._1208 = _1208;
}
public PoiProductProductSpuAttributes _1209(PoiProductProductSpuAttributes1209 _1209) {
this._1209 = _1209;
return this;
}
/**
* Get _1209
* @return _1209
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1209 get1209() {
return _1209;
}
public void set1209(PoiProductProductSpuAttributes1209 _1209) {
this._1209 = _1209;
}
public PoiProductProductSpuAttributes _1210(String _1210) {
this._1210 = _1210;
return this;
}
/**
* 景观
* @return _1210
**/
@Schema(example = "海滩景观", description = "景观")
public String get1210() {
return _1210;
}
public void set1210(String _1210) {
this._1210 = _1210;
}
public PoiProductProductSpuAttributes _1211(PoiProductProductSpuAttributes1211 _1211) {
this._1211 = _1211;
return this;
}
/**
* Get _1211
* @return _1211
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1211 get1211() {
return _1211;
}
public void set1211(PoiProductProductSpuAttributes1211 _1211) {
this._1211 = _1211;
}
public PoiProductProductSpuAttributes _1212(PoiProductProductSpuAttributes1212 _1212) {
this._1212 = _1212;
return this;
}
/**
* Get _1212
* @return _1212
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1212 get1212() {
return _1212;
}
public void set1212(PoiProductProductSpuAttributes1212 _1212) {
this._1212 = _1212;
}
public PoiProductProductSpuAttributes _1213(PoiProductProductSpuAttributes1213 _1213) {
this._1213 = _1213;
return this;
}
/**
* Get _1213
* @return _1213
**/
@Schema(description = "")
public PoiProductProductSpuAttributes1213 get1213() {
return _1213;
}
public void set1213(PoiProductProductSpuAttributes1213 _1213) {
this._1213 = _1213;
}
public PoiProductProductSpuAttributes _1214(_1214Enum _1214) {
this._1214 = _1214;
return this;
}
/**
* 早餐; 0 - 无早餐; 1~9 - n份早餐; 10 - 多份早餐
* @return _1214
**/
@Schema(description = "早餐; 0 - 无早餐; 1~9 - n份早餐; 10 - 多份早餐")
public _1214Enum get1214() {
return _1214;
}
public void set1214(_1214Enum _1214) {
this._1214 = _1214;
}
public PoiProductProductSpuAttributes _90201(PoiProductProductSpuAttributes90201 _90201) {
this._90201 = _90201;
return this;
}
/**
* Get _90201
* @return _90201
**/
@Schema(description = "")
public PoiProductProductSpuAttributes90201 get90201() {
return _90201;
}
public void set90201(PoiProductProductSpuAttributes90201 _90201) {
this._90201 = _90201;
}
public PoiProductProductSpuAttributes _90202(_90202Enum _90202) {
this._90202 = _90202;
return this;
}
/**
* 是否可退 1- 随时退，2-不可退, 3-有条件退
* @return _90202
**/
@Schema(description = "是否可退 1- 随时退，2-不可退, 3-有条件退")
public _90202Enum get90202() {
return _90202;
}
public void set90202(_90202Enum _90202) {
this._90202 = _90202;
}
public PoiProductProductSpuAttributes _90203(_90203Enum _90203) {
this._90203 = _90203;
return this;
}
/**
* 取票信息 1-需要取票 2-无需取票
* @return _90203
**/
@Schema(description = "取票信息 1-需要取票 2-无需取票")
public _90203Enum get90203() {
return _90203;
}
public void set90203(_90203Enum _90203) {
this._90203 = _90203;
}
public PoiProductProductSpuAttributes _90204(Integer _90204) {
this._90204 = _90204;
return this;
}
/**
* 门票价格(展示最近7日最低价，精确到分)
* @return _90204
**/
@Schema(example = "16800", description = "门票价格(展示最近7日最低价，精确到分)")
public Integer get90204() {
return _90204;
}
public void set90204(Integer _90204) {
this._90204 = _90204;
}
public PoiProductProductSpuAttributes _90205(PoiProductProductSpuAttributes90205 _90205) {
this._90205 = _90205;
return this;
}
/**
* Get _90205
* @return _90205
**/
@Schema(description = "")
public PoiProductProductSpuAttributes90205 get90205() {
return _90205;
}
public void set90205(PoiProductProductSpuAttributes90205 _90205) {
this._90205 = _90205;
}
public PoiProductProductSpuAttributes _4101(PoiProductProductSpuAttributes4101 _4101) {
this._4101 = _4101;
return this;
}
/**
* Get _4101
* @return _4101
**/
@Schema(description = "")
public PoiProductProductSpuAttributes4101 get4101() {
return _4101;
}
public void set4101(PoiProductProductSpuAttributes4101 _4101) {
this._4101 = _4101;
}
public PoiProductProductSpuAttributes _9101(PoiProductProductSpuAttributes9101 _9101) {
this._9101 = _9101;
return this;
}
/**
* Get _9101
* @return _9101
**/
@Schema(description = "")
public PoiProductProductSpuAttributes9101 get9101() {
return _9101;
}
public void set9101(PoiProductProductSpuAttributes9101 _9101) {
this._9101 = _9101;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
PoiProductProductSpuAttributes spuAttributes = (PoiProductProductSpuAttributes) o;
return Objects.equals(this._1201, spuAttributes._1201) &&
Objects.equals(this._1202, spuAttributes._1202) &&
Objects.equals(this._1203, spuAttributes._1203) &&
Objects.equals(this._1204, spuAttributes._1204) &&
Objects.equals(this._1205, spuAttributes._1205) &&
Objects.equals(this._1206, spuAttributes._1206) &&
Objects.equals(this._1207, spuAttributes._1207) &&
Objects.equals(this._1208, spuAttributes._1208) &&
Objects.equals(this._1209, spuAttributes._1209) &&
Objects.equals(this._1210, spuAttributes._1210) &&
Objects.equals(this._1211, spuAttributes._1211) &&
Objects.equals(this._1212, spuAttributes._1212) &&
Objects.equals(this._1213, spuAttributes._1213) &&
Objects.equals(this._1214, spuAttributes._1214) &&
Objects.equals(this._90201, spuAttributes._90201) &&
Objects.equals(this._90202, spuAttributes._90202) &&
Objects.equals(this._90203, spuAttributes._90203) &&
Objects.equals(this._90204, spuAttributes._90204) &&
Objects.equals(this._90205, spuAttributes._90205) &&
Objects.equals(this._4101, spuAttributes._4101) &&
Objects.equals(this._9101, spuAttributes._9101);
}
@Override
public int hashCode() {
return Objects.hash(_1201, _1202, _1203, _1204, _1205, _1206, _1207, _1208, _1209, _1210, _1211, _1212, _1213, _1214, _90201, _90202, _90203, _90204, _90205, _4101, _9101);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class PoiProductProductSpuAttributes {\n");
sb.append(" _1201: ").append(toIndentedString(_1201)).append("\n");
sb.append(" _1202: ").append(toIndentedString(_1202)).append("\n");
sb.append(" _1203: ").append(toIndentedString(_1203)).append("\n");
sb.append(" _1204: ").append(toIndentedString(_1204)).append("\n");
sb.append(" _1205: ").append(toIndentedString(_1205)).append("\n");
sb.append(" _1206: ").append(toIndentedString(_1206)).append("\n");
sb.append(" _1207: ").append(toIndentedString(_1207)).append("\n");
sb.append(" _1208: ").append(toIndentedString(_1208)).append("\n");
sb.append(" _1209: ").append(toIndentedString(_1209)).append("\n");
sb.append(" _1210: ").append(toIndentedString(_1210)).append("\n");
sb.append(" _1211: ").append(toIndentedString(_1211)).append("\n");
sb.append(" _1212: ").append(toIndentedString(_1212)).append("\n");
sb.append(" _1213: ").append(toIndentedString(_1213)).append("\n");
sb.append(" _1214: ").append(toIndentedString(_1214)).append("\n");
sb.append(" _90201: ").append(toIndentedString(_90201)).append("\n");
sb.append(" _90202: ").append(toIndentedString(_90202)).append("\n");
sb.append(" _90203: ").append(toIndentedString(_90203)).append("\n");
sb.append(" _90204: ").append(toIndentedString(_90204)).append("\n");
sb.append(" _90205: ").append(toIndentedString(_90205)).append("\n");
sb.append(" _4101: ").append(toIndentedString(_4101)).append("\n");
sb.append(" _9101: ").append(toIndentedString(_9101)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
| true |
43786_1 | package com.chenxin.util.consts;
/**
* @Description 词义分析常量类
* @Date 2020/9/18 16:03
* @Author by 尘心
*/
public class LexerConstants {
/**
* <p>
* 词性缩略说明
*
n 普通名词 f 方位名词 s 处所名词 t 时间名词
nr 人名 ns 地名 nt 机构团体名 nw 作品名
nz 其他专名 v 普通动词 vd 动副词 vn 名动词
a 形容词 ad 副形词 an 名形词 d 副词
m 数量词 q 量词 r 代词 p 介词
c 连词 u 助词 xc 其他虚词
* </p>
*/
public static final String N = "n";
public static final String NT = "nt";
public static final String A = "a";
public static final String AD = "ad";
public static final String V = "v";
public static final String VD = "vd";
public static final String VN = "vn";
}
| LovebuildJ/language-ai | src/main/java/com/chenxin/util/consts/LexerConstants.java | 296 | /**
* <p>
* 词性缩略说明
*
n 普通名词 f 方位名词 s 处所名词 t 时间名词
nr 人名 ns 地名 nt 机构团体名 nw 作品名
nz 其他专名 v 普通动词 vd 动副词 vn 名动词
a 形容词 ad 副形词 an 名形词 d 副词
m 数量词 q 量词 r 代词 p 介词
c 连词 u 助词 xc 其他虚词
* </p>
*/ | block_comment | zh-cn | package com.chenxin.util.consts;
/**
* @Description 词义分析常量类
* @Date 2020/9/18 16:03
* @Author by 尘心
*/
public class LexerConstants {
/**
* <p> <SUF>*/
public static final String N = "n";
public static final String NT = "nt";
public static final String A = "a";
public static final String AD = "ad";
public static final String V = "v";
public static final String VD = "vd";
public static final String VN = "vn";
}
| false |
61683_4 | package Model;
public class SchoolInformation {
String schoolid;
String name;
String sex;
String birthday;
String people;
String zzmm;//政治面貌
String IdCard;//身份证
String xjzt;//学籍状态
String xy;//学院
String grade;//年级
String major;//专业
String clas;//班级
String majorid;//专业代码
String examid;//考生号
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public String getSchoolid() {
return schoolid;
}
public void setSchoolid(String schoolid) {
this.schoolid = schoolid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getPeople() {
return people;
}
public void setPeople(String people) {
this.people = people;
}
public String getZzmm() {
return zzmm;
}
public void setZzmm(String zzmm) {
this.zzmm = zzmm;
}
public String getIdCard() {
return IdCard;
}
public void setIdCard(String idCard) {
IdCard = idCard;
}
public String getXjzt() {
return xjzt;
}
public void setXjzt(String xjzt) {
this.xjzt = xjzt;
}
public String getXy() {
return xy;
}
public void setXy(String xy) {
this.xy = xy;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public String getClas() {
return clas;
}
public void setClas(String clas) {
this.clas = clas;
}
public String getMajorid() {
return majorid;
}
public void setMajorid(String majorid) {
this.majorid = majorid;
}
public String getExamid() {
return examid;
}
public void setExamid(String examid) {
this.examid = examid;
}
}
| LovelyWhite/AttendanceSystem | 后端/src/Model/SchoolInformation.java | 591 | //考生号 | line_comment | zh-cn | package Model;
public class SchoolInformation {
String schoolid;
String name;
String sex;
String birthday;
String people;
String zzmm;//政治面貌
String IdCard;//身份证
String xjzt;//学籍状态
String xy;//学院
String grade;//年级
String major;//专业
String clas;//班级
String majorid;//专业代码
String examid;//考生 <SUF>
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
public String getSchoolid() {
return schoolid;
}
public void setSchoolid(String schoolid) {
this.schoolid = schoolid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getPeople() {
return people;
}
public void setPeople(String people) {
this.people = people;
}
public String getZzmm() {
return zzmm;
}
public void setZzmm(String zzmm) {
this.zzmm = zzmm;
}
public String getIdCard() {
return IdCard;
}
public void setIdCard(String idCard) {
IdCard = idCard;
}
public String getXjzt() {
return xjzt;
}
public void setXjzt(String xjzt) {
this.xjzt = xjzt;
}
public String getXy() {
return xy;
}
public void setXy(String xy) {
this.xy = xy;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public String getClas() {
return clas;
}
public void setClas(String clas) {
this.clas = clas;
}
public String getMajorid() {
return majorid;
}
public void setMajorid(String majorid) {
this.majorid = majorid;
}
public String getExamid() {
return examid;
}
public void setExamid(String examid) {
this.examid = examid;
}
}
| false |
17518_8 | package com.zh.pojo;
public class Question {
/**问题编号*/
private Integer questionId;
/**问题名称*/
private String quesName;
/**选项A*/
private String optionA;
/**选项B*/
private String optionB;
/**选项C*/
private String optionC;
/**选项D*/
private String optionD;
/**标准答案*/
private String answer;
/**学生答案*/
private String userAnswer;
/**对应课程*/
private Integer courseId;
/**题型*/
private Integer typeId;
/**难度（0：容易，1：中等，2：难）*/
private int difficulty;
/**备注*/
private String remark;
private String answerDetail;
private String gradeId;
private String testPointId;
private Course course;
private Type type;
//记录错误的次数
private Integer wrongCount;
//记录该题目被选上的次数
private Integer selectedCount;
public Integer getWrongCount() {
return wrongCount;
}
public void setWrongCount(Integer wrongCount) {
this.wrongCount = wrongCount;
}
public Integer getSelectedCount() {
return selectedCount;
}
public void setSelectedCount(Integer selectedCount) {
this.selectedCount = selectedCount;
}
public String getTestPointId() {
return testPointId;
}
public void setTestPointId(String testPointId) {
this.testPointId = testPointId;
}
public Course getCourse() {
return course;
}
public void setCourse(Course course) {
this.course = course;
}
public Type getType() {
return type;
}
public void setType(Type type) {
this.type = type;
}
public Integer getCourseId() {
return courseId;
}
public void setCourseId(Integer courseId) {
this.courseId = courseId;
}
public Integer getTypeId() {
return typeId;
}
public void setTypeId(Integer typeId) {
this.typeId = typeId;
}
public String getQuesName() {
return quesName;
}
public Integer getQuestionId() {
return questionId;
}
public void setQuestionId(Integer questionId) {
this.questionId = questionId;
}
public void setQuesName(String quesName) {
this.quesName = quesName;
}
public String getOptionA() {
return optionA;
}
public void setOptionA(String optionA) {
this.optionA = optionA;
}
public String getOptionB() {
return optionB;
}
public void setOptionB(String optionB) {
this.optionB = optionB;
}
public String getOptionC() {
return optionC;
}
public void setOptionC(String optionC) {
this.optionC = optionC;
}
public String getOptionD() {
return optionD;
}
public void setOptionD(String optionD) {
this.optionD = optionD;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
public String getUserAnswer() {
return userAnswer;
}
public void setUserAnswer(String userAnswer) {
this.userAnswer = userAnswer;
}
public int getDifficulty() {
return difficulty;
}
public void setDifficulty(int difficulty) {
this.difficulty = difficulty;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getAnswerDetail() {
return answerDetail;
}
public void setAnswerDetail(String answerDetail) {
this.answerDetail = answerDetail;
}
public String getGradeId() {
return gradeId;
}
public void setGradeId(String gradeId) {
this.gradeId = gradeId;
}
public Question() {
}
public Question(int questionId, String quesName, String optionA,
String optionB, String optionC, String optionD, String answer,
String userAnswer, Integer courseId, Integer typeId, int difficulty,
String remark, String answerDetail, String gradeId) {
super();
this.questionId = questionId;
this.quesName = quesName;
this.optionA = optionA;
this.optionB = optionB;
this.optionC = optionC;
this.optionD = optionD;
this.answer = answer;
this.userAnswer = userAnswer;
this.courseId = courseId;
this.typeId = typeId;
this.difficulty = difficulty;
this.remark = remark;
this.answerDetail = answerDetail;
this.gradeId = gradeId;
}
@Override
public String toString() {
return "Question [questionId=" + questionId + ", quesName=" + quesName
+ ", optionA=" + optionA + ", optionB=" + optionB
+ ", optionC=" + optionC + ", optionD=" + optionD + ", answer="
+ answer + ", userAnswer=" + userAnswer + ", courseId="
+ courseId + ", typeId=" + typeId + ", difficulty="
+ difficulty + ", remark=" + remark + ", answerDetail="
+ answerDetail + ", gradeId=" + gradeId + "]";
}
}
| Lovelylys/examOnline | src/main/java/com/zh/pojo/Question.java | 1,420 | /**对应课程*/ | block_comment | zh-cn | package com.zh.pojo;
public class Question {
/**问题编号*/
private Integer questionId;
/**问题名称*/
private String quesName;
/**选项A*/
private String optionA;
/**选项B*/
private String optionB;
/**选项C*/
private String optionC;
/**选项D*/
private String optionD;
/**标准答案*/
private String answer;
/**学生答案*/
private String userAnswer;
/**对应课 <SUF>*/
private Integer courseId;
/**题型*/
private Integer typeId;
/**难度（0：容易，1：中等，2：难）*/
private int difficulty;
/**备注*/
private String remark;
private String answerDetail;
private String gradeId;
private String testPointId;
private Course course;
private Type type;
//记录错误的次数
private Integer wrongCount;
//记录该题目被选上的次数
private Integer selectedCount;
public Integer getWrongCount() {
return wrongCount;
}
public void setWrongCount(Integer wrongCount) {
this.wrongCount = wrongCount;
}
public Integer getSelectedCount() {
return selectedCount;
}
public void setSelectedCount(Integer selectedCount) {
this.selectedCount = selectedCount;
}
public String getTestPointId() {
return testPointId;
}
public void setTestPointId(String testPointId) {
this.testPointId = testPointId;
}
public Course getCourse() {
return course;
}
public void setCourse(Course course) {
this.course = course;
}
public Type getType() {
return type;
}
public void setType(Type type) {
this.type = type;
}
public Integer getCourseId() {
return courseId;
}
public void setCourseId(Integer courseId) {
this.courseId = courseId;
}
public Integer getTypeId() {
return typeId;
}
public void setTypeId(Integer typeId) {
this.typeId = typeId;
}
public String getQuesName() {
return quesName;
}
public Integer getQuestionId() {
return questionId;
}
public void setQuestionId(Integer questionId) {
this.questionId = questionId;
}
public void setQuesName(String quesName) {
this.quesName = quesName;
}
public String getOptionA() {
return optionA;
}
public void setOptionA(String optionA) {
this.optionA = optionA;
}
public String getOptionB() {
return optionB;
}
public void setOptionB(String optionB) {
this.optionB = optionB;
}
public String getOptionC() {
return optionC;
}
public void setOptionC(String optionC) {
this.optionC = optionC;
}
public String getOptionD() {
return optionD;
}
public void setOptionD(String optionD) {
this.optionD = optionD;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
public String getUserAnswer() {
return userAnswer;
}
public void setUserAnswer(String userAnswer) {
this.userAnswer = userAnswer;
}
public int getDifficulty() {
return difficulty;
}
public void setDifficulty(int difficulty) {
this.difficulty = difficulty;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getAnswerDetail() {
return answerDetail;
}
public void setAnswerDetail(String answerDetail) {
this.answerDetail = answerDetail;
}
public String getGradeId() {
return gradeId;
}
public void setGradeId(String gradeId) {
this.gradeId = gradeId;
}
public Question() {
}
public Question(int questionId, String quesName, String optionA,
String optionB, String optionC, String optionD, String answer,
String userAnswer, Integer courseId, Integer typeId, int difficulty,
String remark, String answerDetail, String gradeId) {
super();
this.questionId = questionId;
this.quesName = quesName;
this.optionA = optionA;
this.optionB = optionB;
this.optionC = optionC;
this.optionD = optionD;
this.answer = answer;
this.userAnswer = userAnswer;
this.courseId = courseId;
this.typeId = typeId;
this.difficulty = difficulty;
this.remark = remark;
this.answerDetail = answerDetail;
this.gradeId = gradeId;
}
@Override
public String toString() {
return "Question [questionId=" + questionId + ", quesName=" + quesName
+ ", optionA=" + optionA + ", optionB=" + optionB
+ ", optionC=" + optionC + ", optionD=" + optionD + ", answer="
+ answer + ", userAnswer=" + userAnswer + ", courseId="
+ courseId + ", typeId=" + typeId + ", difficulty="
+ difficulty + ", remark=" + remark + ", answerDetail="
+ answerDetail + ", gradeId=" + gradeId + "]";
}
}
| false |
29991_2 | package xyz.lovemma.zhihudaily.bean;
import xyz.lovemma.zhihudaily.utils.DateUtils;
/**
* Created by OO on 2017/2/24.
*/
public class StoryContentComment implements BaseItem{
/**
* author : 少先大队委员长
* content : “中国三四线城市现在拥有苹果手机的人数量不在少数”作者这句话的前提是一二线城市现在拥有苹果手机的人非常多。你可能是听多了国内各大厂商对自家手机的宣传所以才会产生苹果越来越差，国产机完全秒杀的错觉。另外就硬件来讲安卓在屏幕，像素，cpu,ram等方面上多年来一直是强过苹果的，但是体验上却很少能有与苹果比肩的，系统的流畅度不是单纯的硬件堆砌能实现的。至于安卓超越ios这个就太夸张了，只能说各有优劣，适合自己的才是最好的，另外安卓与ios多年来也是互相借鉴，谈不上抄袭，毕竟用户需求摆在那里，大家共同进步更好，再考虑到国内对谷歌的阉割所以就国内的体验来讲我觉得安卓还是远远落后于ios的，至于各家的UI也是双刃剑的，符合了国人的使用习惯但是广告太多之类的小问题也是不少。“独创性，改革意义”这种事不是短短几年内就会多次出现的就像汽车发明这么多年了不还是依然四个轱辘么，也没见它上天也没见它下海，要有耐心。以上是我的个人意见
* avatar : http://pic1.zhimg.com/01c635a7439ff86ff7138f93d5a281dc_im.jpg
* time : 1487478427
* reply_to : {"content":"说白了，就是没有原则的的\u201c助手\u201d软件抢了黑心厂商苹果爸爸的钱。\n可能坏处是让正版游戏的收入减少，没有资金进行研发。好处也是有的，竞争性抑制。\u201c玩游戏要钱可以，别太过分啊！要不我换地方了\u201d。不让苹果和游戏厂商心太黑。另外，担心游戏行业无法发展维持的人想太多了，游戏行业的利润总比你想象的多。\n还有一点，作者说:\u201c苹果在三四线城市的占有量还是非常大的\u201d，正好说明了苹果在一二线城市占有率不高。真正懂手机现在不怎么喜欢苹果。\n个人认为，乔帮主之后的苹果，就是个垃鸡。硬件创新每年就那个几年，\u201c独创性\u201d和\u201c改革意义\u201d更是几乎没有。系统研发慢慢的开始成为了\u201c抄安卓\u201d。就靠着乔老爷子开创的\u201c软硬件完美结合\u201d混日子。\n随着安卓硬件的快速发展，几乎快追上苹果，系统更是早就超越苹果，这点是我个人意见。软件的生态优势，强于安卓。\n苹果就是个碌碌无为的混日子公司。早就不是那个智能机的开创者了。当然了，暂时还是死不了。百足之虫，死而不僵。","status":0,"id":28150411,"author":"张文辉"}
* id : 28160966
* likes : 6
*/
private String author;
private String content;
private String avatar;
private int time;
private ReplyToBean reply_to;
private int id;
private int likes;
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getAvatar() {
return avatar;
}
public void setAvatar(String avatar) {
this.avatar = avatar;
}
public String getTime() {
return DateUtils.timestamp2Date(time);
}
public void setTime(int time) {
this.time = time;
}
public ReplyToBean getReply_to() {
return reply_to;
}
public void setReply_to(ReplyToBean reply_to) {
this.reply_to = reply_to;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getLikes() {
return likes;
}
public void setLikes(int likes) {
this.likes = likes;
}
public static class ReplyToBean {
/**
* content : 说白了，就是没有原则的的“助手”软件抢了黑心厂商苹果爸爸的钱。
可能坏处是让正版游戏的收入减少，没有资金进行研发。好处也是有的，竞争性抑制。“玩游戏要钱可以，别太过分啊！要不我换地方了”。不让苹果和游戏厂商心太黑。另外，担心游戏行业无法发展维持的人想太多了，游戏行业的利润总比你想象的多。
还有一点，作者说:“苹果在三四线城市的占有量还是非常大的”，正好说明了苹果在一二线城市占有率不高。真正懂手机现在不怎么喜欢苹果。
个人认为，乔帮主之后的苹果，就是个垃鸡。硬件创新每年就那个几年，“独创性”和“改革意义”更是几乎没有。系统研发慢慢的开始成为了“抄安卓”。就靠着乔老爷子开创的“软硬件完美结合”混日子。
随着安卓硬件的快速发展，几乎快追上苹果，系统更是早就超越苹果，这点是我个人意见。软件的生态优势，强于安卓。
苹果就是个碌碌无为的混日子公司。早就不是那个智能机的开创者了。当然了，暂时还是死不了。百足之虫，死而不僵。
* status : 0
* id : 28150411
* author : 张文辉
*/
private String content;
private int status;
private int id;
private String author;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
}
}
| Lovemma/ZhihuDaily | app/src/main/java/xyz/lovemma/zhihudaily/bean/StoryContentComment.java | 1,927 | /**
* content : 说白了，就是没有原则的的“助手”软件抢了黑心厂商苹果爸爸的钱。
可能坏处是让正版游戏的收入减少，没有资金进行研发。好处也是有的，竞争性抑制。“玩游戏要钱可以，别太过分啊！要不我换地方了”。不让苹果和游戏厂商心太黑。另外，担心游戏行业无法发展维持的人想太多了，游戏行业的利润总比你想象的多。
还有一点，作者说:“苹果在三四线城市的占有量还是非常大的”，正好说明了苹果在一二线城市占有率不高。真正懂手机现在不怎么喜欢苹果。
个人认为，乔帮主之后的苹果，就是个垃鸡。硬件创新每年就那个几年，“独创性”和“改革意义”更是几乎没有。系统研发慢慢的开始成为了“抄安卓”。就靠着乔老爷子开创的“软硬件完美结合”混日子。
随着安卓硬件的快速发展，几乎快追上苹果，系统更是早就超越苹果，这点是我个人意见。软件的生态优势，强于安卓。
苹果就是个碌碌无为的混日子公司。早就不是那个智能机的开创者了。当然了，暂时还是死不了。百足之虫，死而不僵。
* status : 0
* id : 28150411
* author : 张文辉
*/ | block_comment | zh-cn | package xyz.lovemma.zhihudaily.bean;
import xyz.lovemma.zhihudaily.utils.DateUtils;
/**
* Created by OO on 2017/2/24.
*/
public class StoryContentComment implements BaseItem{
/**
* author : 少先大队委员长
* content : “中国三四线城市现在拥有苹果手机的人数量不在少数”作者这句话的前提是一二线城市现在拥有苹果手机的人非常多。你可能是听多了国内各大厂商对自家手机的宣传所以才会产生苹果越来越差，国产机完全秒杀的错觉。另外就硬件来讲安卓在屏幕，像素，cpu,ram等方面上多年来一直是强过苹果的，但是体验上却很少能有与苹果比肩的，系统的流畅度不是单纯的硬件堆砌能实现的。至于安卓超越ios这个就太夸张了，只能说各有优劣，适合自己的才是最好的，另外安卓与ios多年来也是互相借鉴，谈不上抄袭，毕竟用户需求摆在那里，大家共同进步更好，再考虑到国内对谷歌的阉割所以就国内的体验来讲我觉得安卓还是远远落后于ios的，至于各家的UI也是双刃剑的，符合了国人的使用习惯但是广告太多之类的小问题也是不少。“独创性，改革意义”这种事不是短短几年内就会多次出现的就像汽车发明这么多年了不还是依然四个轱辘么，也没见它上天也没见它下海，要有耐心。以上是我的个人意见
* avatar : http://pic1.zhimg.com/01c635a7439ff86ff7138f93d5a281dc_im.jpg
* time : 1487478427
* reply_to : {"content":"说白了，就是没有原则的的\u201c助手\u201d软件抢了黑心厂商苹果爸爸的钱。\n可能坏处是让正版游戏的收入减少，没有资金进行研发。好处也是有的，竞争性抑制。\u201c玩游戏要钱可以，别太过分啊！要不我换地方了\u201d。不让苹果和游戏厂商心太黑。另外，担心游戏行业无法发展维持的人想太多了，游戏行业的利润总比你想象的多。\n还有一点，作者说:\u201c苹果在三四线城市的占有量还是非常大的\u201d，正好说明了苹果在一二线城市占有率不高。真正懂手机现在不怎么喜欢苹果。\n个人认为，乔帮主之后的苹果，就是个垃鸡。硬件创新每年就那个几年，\u201c独创性\u201d和\u201c改革意义\u201d更是几乎没有。系统研发慢慢的开始成为了\u201c抄安卓\u201d。就靠着乔老爷子开创的\u201c软硬件完美结合\u201d混日子。\n随着安卓硬件的快速发展，几乎快追上苹果，系统更是早就超越苹果，这点是我个人意见。软件的生态优势，强于安卓。\n苹果就是个碌碌无为的混日子公司。早就不是那个智能机的开创者了。当然了，暂时还是死不了。百足之虫，死而不僵。","status":0,"id":28150411,"author":"张文辉"}
* id : 28160966
* likes : 6
*/
private String author;
private String content;
private String avatar;
private int time;
private ReplyToBean reply_to;
private int id;
private int likes;
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getAvatar() {
return avatar;
}
public void setAvatar(String avatar) {
this.avatar = avatar;
}
public String getTime() {
return DateUtils.timestamp2Date(time);
}
public void setTime(int time) {
this.time = time;
}
public ReplyToBean getReply_to() {
return reply_to;
}
public void setReply_to(ReplyToBean reply_to) {
this.reply_to = reply_to;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getLikes() {
return likes;
}
public void setLikes(int likes) {
this.likes = likes;
}
public static class ReplyToBean {
/**
* con <SUF>*/
private String content;
private int status;
private int id;
private String author;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
}
}
| false |
47329_0 | package top.easyblog.config;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import top.easyblog.util.SensitiveWordUtils;
/**
* 敏感词过滤器：对标注@SensitiveFilter的类或方法进行敏感词过滤
* 1. 涉政文字：涉及政人物、政治事件、宗教、反动分裂，以及恐怖主义等违规文本
* 2. 色情文字：识别淫秽、污秽、色诱、文爱等涉黄内容，支持重度色情、轻度色情分级
* 3. 辱骂文本：识别各类场景中含有污辱、谩骂、诋毁等辱骂内容
* 4. 违禁文本：识别赌博、刀枪、毒品、造假、贩假等违规内容
* 5. 广告导流：识别利用微信号、手机号、QQ、二维码等开展违法垃圾广告内容
* 6. 垃圾内容：识别水贴、刷屏、无意义等垃圾内容，实现智能反垃圾
*
* @author ：huangxin
* @modified ：
* @since ：2020/11/10 13:39
*/
@Slf4j
@Aspect
public class SensitiveWordAspect {
private SensitiveWordUtils sensitiveWordUtils = SensitiveWordUtils.getInstance();
}
| LoverITer/easyblog | src/main/java/top/easyblog/config/SensitiveWordAspect.java | 391 | /**
* 敏感词过滤器：对标注@SensitiveFilter的类或方法进行敏感词过滤
* 1. 涉政文字：涉及政人物、政治事件、宗教、反动分裂，以及恐怖主义等违规文本
* 2. 色情文字：识别淫秽、污秽、色诱、文爱等涉黄内容，支持重度色情、轻度色情分级
* 3. 辱骂文本：识别各类场景中含有污辱、谩骂、诋毁等辱骂内容
* 4. 违禁文本：识别赌博、刀枪、毒品、造假、贩假等违规内容
* 5. 广告导流：识别利用微信号、手机号、QQ、二维码等开展违法垃圾广告内容
* 6. 垃圾内容：识别水贴、刷屏、无意义等垃圾内容，实现智能反垃圾
*
* @author ：huangxin
* @modified ：
* @since ：2020/11/10 13:39
*/ | block_comment | zh-cn | package top.easyblog.config;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import top.easyblog.util.SensitiveWordUtils;
/**
* 敏感词 <SUF>*/
@Slf4j
@Aspect
public class SensitiveWordAspect {
private SensitiveWordUtils sensitiveWordUtils = SensitiveWordUtils.getInstance();
}
| false |
46949_24 | package com.lovnx.web;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
* @Class RateLimiter 实现基于令牌桶算法,有两个参数：
*
* @para burstSize - 允许作为突发事件进入系统的最大请求数
* @para averageRate - 预期的每秒请求数（ratelimiters使用分钟也支持）
*
* @author yezhiyuan
*/
public class RateLimiter {
//限流时间单位
private final long rateToMsConversion;
//当前可供消费的令牌数量
private final AtomicInteger consumedTokens = new AtomicInteger();
//上一次填充令牌的时间戳
private final AtomicLong lastRefillTime = new AtomicLong(0);
//限流时间单位可设置为TimeUnit.SECONDS,已废弃
@Deprecated
public RateLimiter() {
this(TimeUnit.SECONDS);
}
//限流时间单位可设置为TimeUnit.SECONDS或TimeUnit.MINUTES
public RateLimiter(TimeUnit averageRateUnit) {
switch (averageRateUnit) {
case SECONDS:
rateToMsConversion = 1000;
break;
case MINUTES:
rateToMsConversion = 60 * 1000;
break;
default:
throw new IllegalArgumentException("TimeUnit of " + averageRateUnit + " is not supported");
}
}
//这个方法默认传的当前系统时间戳
public boolean acquire(int burstSize, long averageRate) {
return acquire(burstSize, averageRate, System.currentTimeMillis());
}
public boolean acquire(int burstSize, long averageRate, long currentTimeMillis) {
//这里为了避免傻白甜将burstSize和averageRate设为负值而抛出异常
if (burstSize <= 0 || averageRate <= 0) {
return true;
}
//填充令牌
refillToken(burstSize, averageRate, currentTimeMillis);
//消费令牌成功与否
return consumeToken(burstSize);
}
private void refillToken(int burstSize, long averageRate, long currentTimeMillis) {
//得到上一次填充令牌的时间戳
long refillTime = lastRefillTime.get();
//时间间隔timeDelta = 传进来的时间戳currentTimeMillis - 上一次填充令牌的时间戳refillTime
long timeDelta = currentTimeMillis - refillTime;
//计算出新的令牌数量newTokens = 时间间隔 * 平均速率 / 限流时间单位
long newTokens = timeDelta * averageRate / rateToMsConversion;
//如果新的令牌数量大于0个
if (newTokens > 0) {
//设置新的填充令牌时间戳newRefillTime，如果上一次填充令牌的时间戳==0就取传进来的currentTimeMillis，如果！=0，
//就等于上一次填充令牌的时间戳 + 新的令牌数量 * 限流时间单位 / 平均速率
long newRefillTime = refillTime == 0
? currentTimeMillis
: refillTime + newTokens * rateToMsConversion / averageRate;
//如果lastRefillTime内存偏移量值==上一次填充令牌的时间戳refillTime，则将lastRefillTime内存值设置为新的填充令牌时间戳newRefillTime
//成功时进入条件体放令牌
if (lastRefillTime.compareAndSet(refillTime, newRefillTime)) {
//放令牌（核心代码）
while (true) {
//得到当前已消费的令牌数量currentLevel
int currentLevel = consumedTokens.get();
//获取校正令牌数量adjustedLevel，从当前已消费的令牌数量currentLevel和允许最大请求数burstSize间取小者，以防允许最大请求数burstSize变小
//这一步和下一步叫做“流量削峰”
int adjustedLevel = Math.min(currentLevel, burstSize);
//获取新的令牌数量newLevel，0 与 （校正值 - 计算值）之间取大者
int newLevel = (int) Math.max(0, adjustedLevel - newTokens);
//如果当前已消费的令牌内存偏移量等于consumedTokens等于currentLevel，则将已消费的令牌量consumedTokens设置为新的令牌数量newLevel
//终止放令牌,在已消费偏移量不等于currentLevel时循环计算，直到它们相等
if (consumedTokens.compareAndSet(currentLevel, newLevel)) {
return;
}
}
}
}
}
//消费令牌，传入突发量
private boolean consumeToken(int burstSize) {
//取令牌
while (true) {
//得到当前已消费的令牌数量currentLevel
int currentLevel = consumedTokens.get();
//如果已消费令牌量大于等于突发量，则不能消费令牌
if (currentLevel >= burstSize) {
return false;
}
//消费令牌，已消费令牌量+1
if (consumedTokens.compareAndSet(currentLevel, currentLevel + 1)) {
return true;
}
}
}
//重置令牌桶
public void reset() {
consumedTokens.set(0);
lastRefillTime.set(0);
}
} | Lovnx/micro-service | service-B/src/main/java/com/lovnx/web/RateLimiter.java | 1,239 | //终止放令牌,在已消费偏移量不等于currentLevel时循环计算，直到它们相等
| line_comment | zh-cn | package com.lovnx.web;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
* @Class RateLimiter 实现基于令牌桶算法,有两个参数：
*
* @para burstSize - 允许作为突发事件进入系统的最大请求数
* @para averageRate - 预期的每秒请求数（ratelimiters使用分钟也支持）
*
* @author yezhiyuan
*/
public class RateLimiter {
//限流时间单位
private final long rateToMsConversion;
//当前可供消费的令牌数量
private final AtomicInteger consumedTokens = new AtomicInteger();
//上一次填充令牌的时间戳
private final AtomicLong lastRefillTime = new AtomicLong(0);
//限流时间单位可设置为TimeUnit.SECONDS,已废弃
@Deprecated
public RateLimiter() {
this(TimeUnit.SECONDS);
}
//限流时间单位可设置为TimeUnit.SECONDS或TimeUnit.MINUTES
public RateLimiter(TimeUnit averageRateUnit) {
switch (averageRateUnit) {
case SECONDS:
rateToMsConversion = 1000;
break;
case MINUTES:
rateToMsConversion = 60 * 1000;
break;
default:
throw new IllegalArgumentException("TimeUnit of " + averageRateUnit + " is not supported");
}
}
//这个方法默认传的当前系统时间戳
public boolean acquire(int burstSize, long averageRate) {
return acquire(burstSize, averageRate, System.currentTimeMillis());
}
public boolean acquire(int burstSize, long averageRate, long currentTimeMillis) {
//这里为了避免傻白甜将burstSize和averageRate设为负值而抛出异常
if (burstSize <= 0 || averageRate <= 0) {
return true;
}
//填充令牌
refillToken(burstSize, averageRate, currentTimeMillis);
//消费令牌成功与否
return consumeToken(burstSize);
}
private void refillToken(int burstSize, long averageRate, long currentTimeMillis) {
//得到上一次填充令牌的时间戳
long refillTime = lastRefillTime.get();
//时间间隔timeDelta = 传进来的时间戳currentTimeMillis - 上一次填充令牌的时间戳refillTime
long timeDelta = currentTimeMillis - refillTime;
//计算出新的令牌数量newTokens = 时间间隔 * 平均速率 / 限流时间单位
long newTokens = timeDelta * averageRate / rateToMsConversion;
//如果新的令牌数量大于0个
if (newTokens > 0) {
//设置新的填充令牌时间戳newRefillTime，如果上一次填充令牌的时间戳==0就取传进来的currentTimeMillis，如果！=0，
//就等于上一次填充令牌的时间戳 + 新的令牌数量 * 限流时间单位 / 平均速率
long newRefillTime = refillTime == 0
? currentTimeMillis
: refillTime + newTokens * rateToMsConversion / averageRate;
//如果lastRefillTime内存偏移量值==上一次填充令牌的时间戳refillTime，则将lastRefillTime内存值设置为新的填充令牌时间戳newRefillTime
//成功时进入条件体放令牌
if (lastRefillTime.compareAndSet(refillTime, newRefillTime)) {
//放令牌（核心代码）
while (true) {
//得到当前已消费的令牌数量currentLevel
int currentLevel = consumedTokens.get();
//获取校正令牌数量adjustedLevel，从当前已消费的令牌数量currentLevel和允许最大请求数burstSize间取小者，以防允许最大请求数burstSize变小
//这一步和下一步叫做“流量削峰”
int adjustedLevel = Math.min(currentLevel, burstSize);
//获取新的令牌数量newLevel，0 与 （校正值 - 计算值）之间取大者
int newLevel = (int) Math.max(0, adjustedLevel - newTokens);
//如果当前已消费的令牌内存偏移量等于consumedTokens等于currentLevel，则将已消费的令牌量consumedTokens设置为新的令牌数量newLevel
//终止 <SUF>
if (consumedTokens.compareAndSet(currentLevel, newLevel)) {
return;
}
}
}
}
}
//消费令牌，传入突发量
private boolean consumeToken(int burstSize) {
//取令牌
while (true) {
//得到当前已消费的令牌数量currentLevel
int currentLevel = consumedTokens.get();
//如果已消费令牌量大于等于突发量，则不能消费令牌
if (currentLevel >= burstSize) {
return false;
}
//消费令牌，已消费令牌量+1
if (consumedTokens.compareAndSet(currentLevel, currentLevel + 1)) {
return true;
}
}
}
//重置令牌桶
public void reset() {
consumedTokens.set(0);
lastRefillTime.set(0);
}
} | true |
53308_2 | package com.lrony.mread.data.net;
import java.util.List;
/**
* Created by Lrony on 18-5-11.
*/
public class HotCommentPackage {
/**
* total : 940
* reviews : [{"_id":"59bd12ddcf9eb0881c200304","rating":2,"author":{"_id":"57128304584d45341d1804bb","avatar":"/avatar/4b/a6/4ba6cb55293ce46480a40565978b0e52","nickname":"天地无能与我何干","activityAvatar":"/activities/20180215/3.jpg","type":"normal","lv":11,"gender":"male"},"helpful":{"total":27575,"yes":28328,"no":753},"likeCount":1225,"state":"normal","updated":"2018-05-11T06:10:59.843Z","created":"2017-09-16T12:02:37.286Z","commentCount":2824,"content":"萧炎说：\u201d我叫萧炎，是一个天天刷级的人。\u201d\n林动说：\u201d我叫林动，是一个天天刷级的人。\u201d\n牧尘说：\u201d我叫牧尘，是一个天天刷级的人。\u201d\n周元说：\u201d我叫周元，是一个天天刷级的人\n萧炎说：\u201d我天天修炼，目标是成为斗帝。\u201d\n林动说：\u201d我天天修炼，目标是成为祖境。\"\n牧尘说：\u201d我天天修炼，目标是成为主宰。;\n周元说：\u201c我天天修炼，目标是。。。额土豆目前还没告诉我。\u201d\n萧炎说：\u201d我的戒指里有个药老，无所不知，比攻略还NB。\u201d\n林动说：\u201d我的石符里有个貂爷，无所不知，比攻略还NB。\u201d\n牧尘说：\u201d我的黑纸里有个九幽雀，无所不知，比攻略还NB。\u201d\n周元说：\u201d我在现实里有个夭夭，无所不知，比攻略还NB。\u201d\n萧炎说：\u201d我那个世界里，有种东西叫异火，威力堪比神器级绝版装备。\u201d\n林动说：\u201d我那个世界里，有种东西叫祖符，威力堪比神器级绝版装备。\u201d\n牧尘说：\u201d我那个世界里，有种东西叫至尊法身，威力堪比神器级绝版装备。\u201d\n周元说：\u201d我那个世界里，有种东西叫圣纹，威力堪比神器级绝版装备。\u201d\n萧炎说：\u201d我出自乌坦城的萧家，是个小少爷。\u201d\n林动说：\u201d我出自青阳镇的林家，是个小少爷。\u201d\n牧尘说：\u201d我出自北灵境的牧域，是个小少爷。\u201d\n周元说：\u201d我出自大周王朝 ，是个小皇子。\u201d\n萧炎说：\u201d我喜欢一个女孩，她叫古熏儿，可他家古族势大，不让我和她在一起。\u201d\n林动说：\u201d我喜欢一个女孩，她叫绫清竹，可她家九天太清宫势大，不让我跟她在一起。\u201d\n牧尘说：\u201d我喜欢一个女孩，她叫洛璃，可她家洛神族势大，不让我跟她在一起。\u201d\n周元说：我喜欢一个女孩，她叫夭夭，可她背后势力强大，不让我跟她在一起。\u201d\n萧炎说：\u201d年少时，我还没有什么远大志向，我唯一的目标就是打败纳兰嫣然。\u201d\n林动说：\u201d年少时，我还没有什么远大志向，我唯一的目标就是杀死林琅天。\u201d\n牧尘说：\u201d小时候，我还没有什么远大志向，我唯一的目标就是打败姬玄。\u201d\n周元说：\u201d小时候，我还没有什么远大志向，我唯一的目标就是杀死武煌。\u201d\n萧炎说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的高级丹药和遇上的远古传承数都数不清。\n林动说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的天材地宝和遇上的远古传承数都数不清。\n牧尘说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的丹药神草和遇上的远古传承数都数不清。\n周元说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来，吃的丹药神草和遇上的远古传承数也都数不清。\u201d\n萧炎说：\u201d我有一个爱好，那就是爱扮猪吃老虎，想当初，我斗皇的时候，栽在我手上的斗宗一大堆。\u201d\n林动说：\u201d我有一个爱好，那就是爱扮猪吃老虎，想当初，我生玄境的时候，栽在我手上的死玄境一大堆。\u201d\n牧尘说：\u201d我有一个爱好，那就是爱扮猪吃老虎，想当初，我化天境的时候，栽在我手上的通天境一大堆。\u201d\n周元说：\u201d我有一个爱好，那就是爱扮猪吃老虎，我养气境的时候，栽在我手上的太初境一大堆。\u201d\n萧炎说：\u201d我有特长，我会炼丹。\u201d\n林动说：\u201d我有特长，我会画符。\u201d\n牧尘说：\u201d我有特长，我会布阵。\u201d\n周元说：\u201d我有特长，我会刻纹。\u201d\n萧炎说：\u201d我有两个老婆。\u201d\n林动说：\u201d我也有两个老婆。\u201d\n牧尘说：;可怜我只有一个老婆。\u201d\n周元说：\u201d正在努力撩妹子（不出意外的话应该是两个以上）。\u201d\n萧炎说：\u201d我的武器是尺子，他叫玄重尺。\u201d\n林动说：\u201d我的武器有很多，他们合称九大神物。\u201d\n牧尘说：\u201d我的武器是一把剑与一根棍子，他们合体称为大须弥圣柱。\n周元说：\u201d我的武器是一支笔，他叫源纹笔。\u201d\n萧炎说：\u201d我最后成就斗帝，打败了魂天帝，夺回了大陆的和平。\u201d\n林动说：\u201d我最后晋级祖境，打败了异魔皇，拯救了世界的万千生灵。\u201d\n牧尘说：\u201d我\u201d最后晋级主宰境，打败了天邪神，拯救了整个大千世界亿亿生灵。\n周元说：\u201d我还没有他们那NB的事迹，我还小，不过我相信我会作出比他们更NB。\u201c\u201d\n萧炎说：\u201d后来，我加入了迦南学院，参加了学员大赛，一战成名。\u201d\n林动说：\u201d后来，我加入了道宗，参加了殿试，一战成名。\u201d\n牧尘说：\u201d后来，我加入北苍灵院，参加了狩猎赛，一战成名。\u201d\n周元说：\u201d后来，我加入苍玄宗，参加圣迹之地，一战成名。\u201d\n萧炎说：\u201d我有一个特NB的大招，叫佛怒火莲。\u201d\n林动说：\u201d我有一个特NB的大招，叫青龙化天决。\u201d\n牧尘说：\u201d我有一个特NB的大招，叫九级浮屠塔。\u201d\n周元说：\u201c我有一个特NB的大招 ，叫祖龙决。\u201d\n萧炎说：\u201d如有雷同。\u201d\n林动说：\u201d纯属巧合。\u201d\n牧尘说：\u201d我也没辙。\u201d\n周元说：\u201d呃。。好巧呀。\u201d","title":"土豆写书的共同特点"},{"_id":"59cfa3d241f903724dd07d1d","rating":1,"author":{"_id":"54bda6dd21e8ef0e5bd939aa","avatar":"/avatar/7c/f9/7cf9c09b71490138441112d96d71f69e","nickname":"好看就看","activityAvatar":"/activities/20180215/4.jpg","type":"normal","lv":9,"gender":"male"},"helpful":{"total":7309,"yes":7891,"no":582},"likeCount":162,"state":"normal","updated":"2018-05-11T05:45:13.718Z","created":"2017-09-30T14:01:54.316Z","commentCount":841,"content":"\u201c他面容坚毅，眼目之间有威严之气，显然久居高位，而其身后，隐有气息升腾，似炎似雷，发出低沉轰鸣之声\u2026\u2026\u201d\n我想说，这是不是在描写这男人在放屁？","title":"第一章第一页"}]
* ok : true
*/
private int total;
private boolean ok;
private List<ReviewsBean> reviews;
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = total;
}
public boolean isOk() {
return ok;
}
public void setOk(boolean ok) {
this.ok = ok;
}
public List<ReviewsBean> getReviews() {
return reviews;
}
public void setReviews(List<ReviewsBean> reviews) {
this.reviews = reviews;
}
public static class ReviewsBean {
/**
* _id : 59bd12ddcf9eb0881c200304
* rating : 2
* author : {"_id":"57128304584d45341d1804bb","avatar":"/avatar/4b/a6/4ba6cb55293ce46480a40565978b0e52","nickname":"天地无能与我何干","activityAvatar":"/activities/20180215/3.jpg","type":"normal","lv":11,"gender":"male"}
* helpful : {"total":27575,"yes":28328,"no":753}
* likeCount : 1225
* state : normal
* updated : 2018-05-11T06:10:59.843Z
* created : 2017-09-16T12:02:37.286Z
* commentCount : 2824
* content : 萧炎说：”我叫萧炎，是一个天天刷级的人。”
林动说：”我叫林动，是一个天天刷级的人。”
牧尘说：”我叫牧尘，是一个天天刷级的人。”
周元说：”我叫周元，是一个天天刷级的人
萧炎说：”我天天修炼，目标是成为斗帝。”
林动说：”我天天修炼，目标是成为祖境。"
牧尘说：”我天天修炼，目标是成为主宰。;
周元说：“我天天修炼，目标是。。。额土豆目前还没告诉我。”
萧炎说：”我的戒指里有个药老，无所不知，比攻略还NB。”
林动说：”我的石符里有个貂爷，无所不知，比攻略还NB。”
牧尘说：”我的黑纸里有个九幽雀，无所不知，比攻略还NB。”
周元说：”我在现实里有个夭夭，无所不知，比攻略还NB。”
萧炎说：”我那个世界里，有种东西叫异火，威力堪比神器级绝版装备。”
林动说：”我那个世界里，有种东西叫祖符，威力堪比神器级绝版装备。”
牧尘说：”我那个世界里，有种东西叫至尊法身，威力堪比神器级绝版装备。”
周元说：”我那个世界里，有种东西叫圣纹，威力堪比神器级绝版装备。”
萧炎说：”我出自乌坦城的萧家，是个小少爷。”
林动说：”我出自青阳镇的林家，是个小少爷。”
牧尘说：”我出自北灵境的牧域，是个小少爷。”
周元说：”我出自大周王朝 ，是个小皇子。”
萧炎说：”我喜欢一个女孩，她叫古熏儿，可他家古族势大，不让我和她在一起。”
林动说：”我喜欢一个女孩，她叫绫清竹，可她家九天太清宫势大，不让我跟她在一起。”
牧尘说：”我喜欢一个女孩，她叫洛璃，可她家洛神族势大，不让我跟她在一起。”
周元说：我喜欢一个女孩，她叫夭夭，可她背后势力强大，不让我跟她在一起。”
萧炎说：”年少时，我还没有什么远大志向，我唯一的目标就是打败纳兰嫣然。”
林动说：”年少时，我还没有什么远大志向，我唯一的目标就是杀死林琅天。”
牧尘说：”小时候，我还没有什么远大志向，我唯一的目标就是打败姬玄。”
周元说：”小时候，我还没有什么远大志向，我唯一的目标就是杀死武煌。”
萧炎说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的高级丹药和遇上的远古传承数都数不清。
林动说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的天材地宝和遇上的远古传承数都数不清。
牧尘说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的丹药神草和遇上的远古传承数都数不清。
周元说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来，吃的丹药神草和遇上的远古传承数也都数不清。”
萧炎说：”我有一个爱好，那就是爱扮猪吃老虎，想当初，我斗皇的时候，栽在我手上的斗宗一大堆。”
林动说：”我有一个爱好，那就是爱扮猪吃老虎，想当初，我生玄境的时候，栽在我手上的死玄境一大堆。”
牧尘说：”我有一个爱好，那就是爱扮猪吃老虎，想当初，我化天境的时候，栽在我手上的通天境一大堆。”
周元说：”我有一个爱好，那就是爱扮猪吃老虎，我养气境的时候，栽在我手上的太初境一大堆。”
萧炎说：”我有特长，我会炼丹。”
林动说：”我有特长，我会画符。”
牧尘说：”我有特长，我会布阵。”
周元说：”我有特长，我会刻纹。”
萧炎说：”我有两个老婆。”
林动说：”我也有两个老婆。”
牧尘说：;可怜我只有一个老婆。”
周元说：”正在努力撩妹子（不出意外的话应该是两个以上）。”
萧炎说：”我的武器是尺子，他叫玄重尺。”
林动说：”我的武器有很多，他们合称九大神物。”
牧尘说：”我的武器是一把剑与一根棍子，他们合体称为大须弥圣柱。
周元说：”我的武器是一支笔，他叫源纹笔。”
萧炎说：”我最后成就斗帝，打败了魂天帝，夺回了大陆的和平。”
林动说：”我最后晋级祖境，打败了异魔皇，拯救了世界的万千生灵。”
牧尘说：”我”最后晋级主宰境，打败了天邪神，拯救了整个大千世界亿亿生灵。
周元说：”我还没有他们那NB的事迹，我还小，不过我相信我会作出比他们更NB。“”
萧炎说：”后来，我加入了迦南学院，参加了学员大赛，一战成名。”
林动说：”后来，我加入了道宗，参加了殿试，一战成名。”
牧尘说：”后来，我加入北苍灵院，参加了狩猎赛，一战成名。”
周元说：”后来，我加入苍玄宗，参加圣迹之地，一战成名。”
萧炎说：”我有一个特NB的大招，叫佛怒火莲。”
林动说：”我有一个特NB的大招，叫青龙化天决。”
牧尘说：”我有一个特NB的大招，叫九级浮屠塔。”
周元说：“我有一个特NB的大招 ，叫祖龙决。”
萧炎说：”如有雷同。”
林动说：”纯属巧合。”
牧尘说：”我也没辙。”
周元说：”呃。。好巧呀。”
* title : 土豆写书的共同特点
*/
private String _id;
private int rating;
private AuthorBean author;
private HelpfulBean helpful;
private int likeCount;
private String state;
private String updated;
private String created;
private int commentCount;
private String content;
private String title;
public String get_id() {
return _id;
}
public void set_id(String _id) {
this._id = _id;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
public AuthorBean getAuthor() {
return author;
}
public void setAuthor(AuthorBean author) {
this.author = author;
}
public HelpfulBean getHelpful() {
return helpful;
}
public void setHelpful(HelpfulBean helpful) {
this.helpful = helpful;
}
public int getLikeCount() {
return likeCount;
}
public void setLikeCount(int likeCount) {
this.likeCount = likeCount;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getUpdated() {
return updated;
}
public void setUpdated(String updated) {
this.updated = updated;
}
public String getCreated() {
return created;
}
public void setCreated(String created) {
this.created = created;
}
public int getCommentCount() {
return commentCount;
}
public void setCommentCount(int commentCount) {
this.commentCount = commentCount;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public static class AuthorBean {
/**
* _id : 57128304584d45341d1804bb
* avatar : /avatar/4b/a6/4ba6cb55293ce46480a40565978b0e52
* nickname : 天地无能与我何干
* activityAvatar : /activities/20180215/3.jpg
* type : normal
* lv : 11
* gender : male
*/
private String _id;
private String avatar;
private String nickname;
private String activityAvatar;
private String type;
private int lv;
private String gender;
public String get_id() {
return _id;
}
public void set_id(String _id) {
this._id = _id;
}
public String getAvatar() {
return avatar;
}
public void setAvatar(String avatar) {
this.avatar = avatar;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getActivityAvatar() {
return activityAvatar;
}
public void setActivityAvatar(String activityAvatar) {
this.activityAvatar = activityAvatar;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getLv() {
return lv;
}
public void setLv(int lv) {
this.lv = lv;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
public static class HelpfulBean {
/**
* total : 27575
* yes : 28328
* no : 753
*/
private int total;
private int yes;
private int no;
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = total;
}
public int getYes() {
return yes;
}
public void setYes(int yes) {
this.yes = yes;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
}
}
}
| Lrony/MRead | app/src/main/java/com/lrony/mread/data/net/HotCommentPackage.java | 6,635 | /**
* _id : 59bd12ddcf9eb0881c200304
* rating : 2
* author : {"_id":"57128304584d45341d1804bb","avatar":"/avatar/4b/a6/4ba6cb55293ce46480a40565978b0e52","nickname":"天地无能与我何干","activityAvatar":"/activities/20180215/3.jpg","type":"normal","lv":11,"gender":"male"}
* helpful : {"total":27575,"yes":28328,"no":753}
* likeCount : 1225
* state : normal
* updated : 2018-05-11T06:10:59.843Z
* created : 2017-09-16T12:02:37.286Z
* commentCount : 2824
* content : 萧炎说：”我叫萧炎，是一个天天刷级的人。”
林动说：”我叫林动，是一个天天刷级的人。”
牧尘说：”我叫牧尘，是一个天天刷级的人。”
周元说：”我叫周元，是一个天天刷级的人
萧炎说：”我天天修炼，目标是成为斗帝。”
林动说：”我天天修炼，目标是成为祖境。"
牧尘说：”我天天修炼，目标是成为主宰。;
周元说：“我天天修炼，目标是。。。额土豆目前还没告诉我。”
萧炎说：”我的戒指里有个药老，无所不知，比攻略还NB。”
林动说：”我的石符里有个貂爷，无所不知，比攻略还NB。”
牧尘说：”我的黑纸里有个九幽雀，无所不知，比攻略还NB。”
周元说：”我在现实里有个夭夭，无所不知，比攻略还NB。”
萧炎说：”我那个世界里，有种东西叫异火，威力堪比神器级绝版装备。”
林动说：”我那个世界里，有种东西叫祖符，威力堪比神器级绝版装备。”
牧尘说：”我那个世界里，有种东西叫至尊法身，威力堪比神器级绝版装备。”
周元说：”我那个世界里，有种东西叫圣纹，威力堪比神器级绝版装备。”
萧炎说：”我出自乌坦城的萧家，是个小少爷。”
林动说：”我出自青阳镇的林家，是个小少爷。”
牧尘说：”我出自北灵境的牧域，是个小少爷。”
周元说：”我出自大周王朝 ，是个小皇子。”
萧炎说：”我喜欢一个女孩，她叫古熏儿，可他家古族势大，不让我和她在一起。”
林动说：”我喜欢一个女孩，她叫绫清竹，可她家九天太清宫势大，不让我跟她在一起。”
牧尘说：”我喜欢一个女孩，她叫洛璃，可她家洛神族势大，不让我跟她在一起。”
周元说：我喜欢一个女孩，她叫夭夭，可她背后势力强大，不让我跟她在一起。”
萧炎说：”年少时，我还没有什么远大志向，我唯一的目标就是打败纳兰嫣然。”
林动说：”年少时，我还没有什么远大志向，我唯一的目标就是杀死林琅天。”
牧尘说：”小时候，我还没有什么远大志向，我唯一的目标就是打败姬玄。”
周元说：”小时候，我还没有什么远大志向，我唯一的目标就是杀死武煌。”
萧炎说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的高级丹药和遇上的远古传承数都数不清。
林动说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的天材地宝和遇上的远古传承数都数不清。
牧尘说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的丹药神草和遇上的远古传承数都数不清。
周元说：”说实话，我之所以有今天的成就，完全是靠机缘砸出来，吃的丹药神草和遇上的远古传承数也都数不清。”
萧炎说：”我有一个爱好，那就是爱扮猪吃老虎，想当初，我斗皇的时候，栽在我手上的斗宗一大堆。”
林动说：”我有一个爱好，那就是爱扮猪吃老虎，想当初，我生玄境的时候，栽在我手上的死玄境一大堆。”
牧尘说：”我有一个爱好，那就是爱扮猪吃老虎，想当初，我化天境的时候，栽在我手上的通天境一大堆。”
周元说：”我有一个爱好，那就是爱扮猪吃老虎，我养气境的时候，栽在我手上的太初境一大堆。”
萧炎说：”我有特长，我会炼丹。”
林动说：”我有特长，我会画符。”
牧尘说：”我有特长，我会布阵。”
周元说：”我有特长，我会刻纹。”
萧炎说：”我有两个老婆。”
林动说：”我也有两个老婆。”
牧尘说：;可怜我只有一个老婆。”
周元说：”正在努力撩妹子（不出意外的话应该是两个以上）。”
萧炎说：”我的武器是尺子，他叫玄重尺。”
林动说：”我的武器有很多，他们合称九大神物。”
牧尘说：”我的武器是一把剑与一根棍子，他们合体称为大须弥圣柱。
周元说：”我的武器是一支笔，他叫源纹笔。”
萧炎说：”我最后成就斗帝，打败了魂天帝，夺回了大陆的和平。”
林动说：”我最后晋级祖境，打败了异魔皇，拯救了世界的万千生灵。”
牧尘说：”我”最后晋级主宰境，打败了天邪神，拯救了整个大千世界亿亿生灵。
周元说：”我还没有他们那NB的事迹，我还小，不过我相信我会作出比他们更NB。“”
萧炎说：”后来，我加入了迦南学院，参加了学员大赛，一战成名。”
林动说：”后来，我加入了道宗，参加了殿试，一战成名。”
牧尘说：”后来，我加入北苍灵院，参加了狩猎赛，一战成名。”
周元说：”后来，我加入苍玄宗，参加圣迹之地，一战成名。”
萧炎说：”我有一个特NB的大招，叫佛怒火莲。”
林动说：”我有一个特NB的大招，叫青龙化天决。”
牧尘说：”我有一个特NB的大招，叫九级浮屠塔。”
周元说：“我有一个特NB的大招 ，叫祖龙决。”
萧炎说：”如有雷同。”
林动说：”纯属巧合。”
牧尘说：”我也没辙。”
周元说：”呃。。好巧呀。”
* title : 土豆写书的共同特点
*/ | block_comment | zh-cn | package com.lrony.mread.data.net;
import java.util.List;
/**
* Created by Lrony on 18-5-11.
*/
public class HotCommentPackage {
/**
* total : 940
* reviews : [{"_id":"59bd12ddcf9eb0881c200304","rating":2,"author":{"_id":"57128304584d45341d1804bb","avatar":"/avatar/4b/a6/4ba6cb55293ce46480a40565978b0e52","nickname":"天地无能与我何干","activityAvatar":"/activities/20180215/3.jpg","type":"normal","lv":11,"gender":"male"},"helpful":{"total":27575,"yes":28328,"no":753},"likeCount":1225,"state":"normal","updated":"2018-05-11T06:10:59.843Z","created":"2017-09-16T12:02:37.286Z","commentCount":2824,"content":"萧炎说：\u201d我叫萧炎，是一个天天刷级的人。\u201d\n林动说：\u201d我叫林动，是一个天天刷级的人。\u201d\n牧尘说：\u201d我叫牧尘，是一个天天刷级的人。\u201d\n周元说：\u201d我叫周元，是一个天天刷级的人\n萧炎说：\u201d我天天修炼，目标是成为斗帝。\u201d\n林动说：\u201d我天天修炼，目标是成为祖境。\"\n牧尘说：\u201d我天天修炼，目标是成为主宰。;\n周元说：\u201c我天天修炼，目标是。。。额土豆目前还没告诉我。\u201d\n萧炎说：\u201d我的戒指里有个药老，无所不知，比攻略还NB。\u201d\n林动说：\u201d我的石符里有个貂爷，无所不知，比攻略还NB。\u201d\n牧尘说：\u201d我的黑纸里有个九幽雀，无所不知，比攻略还NB。\u201d\n周元说：\u201d我在现实里有个夭夭，无所不知，比攻略还NB。\u201d\n萧炎说：\u201d我那个世界里，有种东西叫异火，威力堪比神器级绝版装备。\u201d\n林动说：\u201d我那个世界里，有种东西叫祖符，威力堪比神器级绝版装备。\u201d\n牧尘说：\u201d我那个世界里，有种东西叫至尊法身，威力堪比神器级绝版装备。\u201d\n周元说：\u201d我那个世界里，有种东西叫圣纹，威力堪比神器级绝版装备。\u201d\n萧炎说：\u201d我出自乌坦城的萧家，是个小少爷。\u201d\n林动说：\u201d我出自青阳镇的林家，是个小少爷。\u201d\n牧尘说：\u201d我出自北灵境的牧域，是个小少爷。\u201d\n周元说：\u201d我出自大周王朝 ，是个小皇子。\u201d\n萧炎说：\u201d我喜欢一个女孩，她叫古熏儿，可他家古族势大，不让我和她在一起。\u201d\n林动说：\u201d我喜欢一个女孩，她叫绫清竹，可她家九天太清宫势大，不让我跟她在一起。\u201d\n牧尘说：\u201d我喜欢一个女孩，她叫洛璃，可她家洛神族势大，不让我跟她在一起。\u201d\n周元说：我喜欢一个女孩，她叫夭夭，可她背后势力强大，不让我跟她在一起。\u201d\n萧炎说：\u201d年少时，我还没有什么远大志向，我唯一的目标就是打败纳兰嫣然。\u201d\n林动说：\u201d年少时，我还没有什么远大志向，我唯一的目标就是杀死林琅天。\u201d\n牧尘说：\u201d小时候，我还没有什么远大志向，我唯一的目标就是打败姬玄。\u201d\n周元说：\u201d小时候，我还没有什么远大志向，我唯一的目标就是杀死武煌。\u201d\n萧炎说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的高级丹药和遇上的远古传承数都数不清。\n林动说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的天材地宝和遇上的远古传承数都数不清。\n牧尘说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来的，吃的丹药神草和遇上的远古传承数都数不清。\n周元说：\u201d说实话，我之所以有今天的成就，完全是靠机缘砸出来，吃的丹药神草和遇上的远古传承数也都数不清。\u201d\n萧炎说：\u201d我有一个爱好，那就是爱扮猪吃老虎，想当初，我斗皇的时候，栽在我手上的斗宗一大堆。\u201d\n林动说：\u201d我有一个爱好，那就是爱扮猪吃老虎，想当初，我生玄境的时候，栽在我手上的死玄境一大堆。\u201d\n牧尘说：\u201d我有一个爱好，那就是爱扮猪吃老虎，想当初，我化天境的时候，栽在我手上的通天境一大堆。\u201d\n周元说：\u201d我有一个爱好，那就是爱扮猪吃老虎，我养气境的时候，栽在我手上的太初境一大堆。\u201d\n萧炎说：\u201d我有特长，我会炼丹。\u201d\n林动说：\u201d我有特长，我会画符。\u201d\n牧尘说：\u201d我有特长，我会布阵。\u201d\n周元说：\u201d我有特长，我会刻纹。\u201d\n萧炎说：\u201d我有两个老婆。\u201d\n林动说：\u201d我也有两个老婆。\u201d\n牧尘说：;可怜我只有一个老婆。\u201d\n周元说：\u201d正在努力撩妹子（不出意外的话应该是两个以上）。\u201d\n萧炎说：\u201d我的武器是尺子，他叫玄重尺。\u201d\n林动说：\u201d我的武器有很多，他们合称九大神物。\u201d\n牧尘说：\u201d我的武器是一把剑与一根棍子，他们合体称为大须弥圣柱。\n周元说：\u201d我的武器是一支笔，他叫源纹笔。\u201d\n萧炎说：\u201d我最后成就斗帝，打败了魂天帝，夺回了大陆的和平。\u201d\n林动说：\u201d我最后晋级祖境，打败了异魔皇，拯救了世界的万千生灵。\u201d\n牧尘说：\u201d我\u201d最后晋级主宰境，打败了天邪神，拯救了整个大千世界亿亿生灵。\n周元说：\u201d我还没有他们那NB的事迹，我还小，不过我相信我会作出比他们更NB。\u201c\u201d\n萧炎说：\u201d后来，我加入了迦南学院，参加了学员大赛，一战成名。\u201d\n林动说：\u201d后来，我加入了道宗，参加了殿试，一战成名。\u201d\n牧尘说：\u201d后来，我加入北苍灵院，参加了狩猎赛，一战成名。\u201d\n周元说：\u201d后来，我加入苍玄宗，参加圣迹之地，一战成名。\u201d\n萧炎说：\u201d我有一个特NB的大招，叫佛怒火莲。\u201d\n林动说：\u201d我有一个特NB的大招，叫青龙化天决。\u201d\n牧尘说：\u201d我有一个特NB的大招，叫九级浮屠塔。\u201d\n周元说：\u201c我有一个特NB的大招 ，叫祖龙决。\u201d\n萧炎说：\u201d如有雷同。\u201d\n林动说：\u201d纯属巧合。\u201d\n牧尘说：\u201d我也没辙。\u201d\n周元说：\u201d呃。。好巧呀。\u201d","title":"土豆写书的共同特点"},{"_id":"59cfa3d241f903724dd07d1d","rating":1,"author":{"_id":"54bda6dd21e8ef0e5bd939aa","avatar":"/avatar/7c/f9/7cf9c09b71490138441112d96d71f69e","nickname":"好看就看","activityAvatar":"/activities/20180215/4.jpg","type":"normal","lv":9,"gender":"male"},"helpful":{"total":7309,"yes":7891,"no":582},"likeCount":162,"state":"normal","updated":"2018-05-11T05:45:13.718Z","created":"2017-09-30T14:01:54.316Z","commentCount":841,"content":"\u201c他面容坚毅，眼目之间有威严之气，显然久居高位，而其身后，隐有气息升腾，似炎似雷，发出低沉轰鸣之声\u2026\u2026\u201d\n我想说，这是不是在描写这男人在放屁？","title":"第一章第一页"}]
* ok : true
*/
private int total;
private boolean ok;
private List<ReviewsBean> reviews;
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = total;
}
public boolean isOk() {
return ok;
}
public void setOk(boolean ok) {
this.ok = ok;
}
public List<ReviewsBean> getReviews() {
return reviews;
}
public void setReviews(List<ReviewsBean> reviews) {
this.reviews = reviews;
}
public static class ReviewsBean {
/**
* _id <SUF>*/
private String _id;
private int rating;
private AuthorBean author;
private HelpfulBean helpful;
private int likeCount;
private String state;
private String updated;
private String created;
private int commentCount;
private String content;
private String title;
public String get_id() {
return _id;
}
public void set_id(String _id) {
this._id = _id;
}
public int getRating() {
return rating;
}
public void setRating(int rating) {
this.rating = rating;
}
public AuthorBean getAuthor() {
return author;
}
public void setAuthor(AuthorBean author) {
this.author = author;
}
public HelpfulBean getHelpful() {
return helpful;
}
public void setHelpful(HelpfulBean helpful) {
this.helpful = helpful;
}
public int getLikeCount() {
return likeCount;
}
public void setLikeCount(int likeCount) {
this.likeCount = likeCount;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getUpdated() {
return updated;
}
public void setUpdated(String updated) {
this.updated = updated;
}
public String getCreated() {
return created;
}
public void setCreated(String created) {
this.created = created;
}
public int getCommentCount() {
return commentCount;
}
public void setCommentCount(int commentCount) {
this.commentCount = commentCount;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public static class AuthorBean {
/**
* _id : 57128304584d45341d1804bb
* avatar : /avatar/4b/a6/4ba6cb55293ce46480a40565978b0e52
* nickname : 天地无能与我何干
* activityAvatar : /activities/20180215/3.jpg
* type : normal
* lv : 11
* gender : male
*/
private String _id;
private String avatar;
private String nickname;
private String activityAvatar;
private String type;
private int lv;
private String gender;
public String get_id() {
return _id;
}
public void set_id(String _id) {
this._id = _id;
}
public String getAvatar() {
return avatar;
}
public void setAvatar(String avatar) {
this.avatar = avatar;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getActivityAvatar() {
return activityAvatar;
}
public void setActivityAvatar(String activityAvatar) {
this.activityAvatar = activityAvatar;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getLv() {
return lv;
}
public void setLv(int lv) {
this.lv = lv;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
public static class HelpfulBean {
/**
* total : 27575
* yes : 28328
* no : 753
*/
private int total;
private int yes;
private int no;
public int getTotal() {
return total;
}
public void setTotal(int total) {
this.total = total;
}
public int getYes() {
return yes;
}
public void setYes(int yes) {
this.yes = yes;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
}
}
}
| false |
31420_1 | import java.awt.*;
import java.awt.image.*;
import java.util.ArrayList;
public abstract class Shooter extends GameObject {
private int HP = 0; //血量
private boolean attacked = false; //记录受到攻击，用于对外观进行闪烁处理
private long time; //记录受击时间，200毫秒后清除受击记录
protected int shootCount = 0; //射击计数
protected int lastShootMoveCount = -1000;
protected int shootInterval = 0;
public void init() {
super.init();
HP = 0;
attacked = false;
shootCount = 0;
lastShootMoveCount = 0;
}
public void setHP(int HP) {
this.HP = HP;
}
//受到damage点伤害，并记录受击时间
public void hit(int damage) {
time = System.currentTimeMillis();
attacked = true;
HP -= damage;
if (HP < 0) {
HP = 0;
}
}
public BufferedImage getAppearance() {
BufferedImage appearance = super.getAppearance();
//attacked为假则直接返回储存的外观
if (!attacked) {
return appearance;
}
//attacked为真则继续以下步骤
//检测100毫秒是否已过，已过则将attacked置否并返回储存的外观
if (System.currentTimeMillis() - time > 100) {
attacked = false;
return appearance;
}
//执行到这说明100毫秒内受到过攻击，则对新外观进行增亮处理，实现闪烁效果
BufferedImage newAppearance = new BufferedImage(appearance.getWidth(), appearance.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics graphics = newAppearance.getGraphics();
graphics.drawImage(appearance, 0, 0, null);
for (int i = 0; i < newAppearance.getWidth(); i++) {
for (int j = 0; j < newAppearance.getHeight(); j++) {
int pixel = newAppearance.getRGB(i, j);
int alpha = (pixel >> 24) & 0xff;
if (alpha == 0)
continue;
Color color = new Color(pixel);
newAppearance.setRGB(i, j, color.brighter().getRGB() & (alpha << 24 | 0xFFFFFF));
}
}
return newAppearance;
}
public int getHP() {
return HP;
}
//以参数中的bullet为模板克隆一份bullet，以自身坐标为偏移量，给bullet设定正确的坐标和速度
protected final Bullet shoot(int x, int y, double vx, double vy, Bullet bullet) {
Bullet newBullet = bullet.clone();
Point bulletPos = getPos();
bulletPos.translate(x, y);
newBullet.setPos(bulletPos);
newBullet.setVelocity(vx, vy);
return newBullet;
}
public abstract ArrayList<Bullet> shoot();
} | Lry722/PlaneWar | Shooter.java | 708 | //记录受击时间，200毫秒后清除受击记录 | line_comment | zh-cn | import java.awt.*;
import java.awt.image.*;
import java.util.ArrayList;
public abstract class Shooter extends GameObject {
private int HP = 0; //血量
private boolean attacked = false; //记录受到攻击，用于对外观进行闪烁处理
private long time; //记录 <SUF>
protected int shootCount = 0; //射击计数
protected int lastShootMoveCount = -1000;
protected int shootInterval = 0;
public void init() {
super.init();
HP = 0;
attacked = false;
shootCount = 0;
lastShootMoveCount = 0;
}
public void setHP(int HP) {
this.HP = HP;
}
//受到damage点伤害，并记录受击时间
public void hit(int damage) {
time = System.currentTimeMillis();
attacked = true;
HP -= damage;
if (HP < 0) {
HP = 0;
}
}
public BufferedImage getAppearance() {
BufferedImage appearance = super.getAppearance();
//attacked为假则直接返回储存的外观
if (!attacked) {
return appearance;
}
//attacked为真则继续以下步骤
//检测100毫秒是否已过，已过则将attacked置否并返回储存的外观
if (System.currentTimeMillis() - time > 100) {
attacked = false;
return appearance;
}
//执行到这说明100毫秒内受到过攻击，则对新外观进行增亮处理，实现闪烁效果
BufferedImage newAppearance = new BufferedImage(appearance.getWidth(), appearance.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics graphics = newAppearance.getGraphics();
graphics.drawImage(appearance, 0, 0, null);
for (int i = 0; i < newAppearance.getWidth(); i++) {
for (int j = 0; j < newAppearance.getHeight(); j++) {
int pixel = newAppearance.getRGB(i, j);
int alpha = (pixel >> 24) & 0xff;
if (alpha == 0)
continue;
Color color = new Color(pixel);
newAppearance.setRGB(i, j, color.brighter().getRGB() & (alpha << 24 | 0xFFFFFF));
}
}
return newAppearance;
}
public int getHP() {
return HP;
}
//以参数中的bullet为模板克隆一份bullet，以自身坐标为偏移量，给bullet设定正确的坐标和速度
protected final Bullet shoot(int x, int y, double vx, double vy, Bullet bullet) {
Bullet newBullet = bullet.clone();
Point bulletPos = getPos();
bulletPos.translate(x, y);
newBullet.setPos(bulletPos);
newBullet.setVelocity(vx, vy);
return newBullet;
}
public abstract ArrayList<Bullet> shoot();
} | true |
41469_9 | package com.cxdai.console.base.entity;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
*
* <p>
* Description:直通车投标日志记录<br />
* </p>
*
* @title FirstTenderLog.java
* @package com.cxdai.base.entity
* @author yangshijin
* @version 0.1 2015年3月11日
*/
public class FirstTenderLog implements Serializable {
private static final long serialVersionUID = 4829448266420311599L;
/**
* 主键Id
*/
private Integer id;
/**
* 直通车开通人ID
*/
private Integer userId;
/**
* 直通车ID
*/
private Integer firstBorrowId;
/**
* 直通车最终记录ID
*/
private Integer firstTenderRealId;
/**
* 用户名
*/
private String username;
/**
* 可用金额（投之前直通车可用余额）
*/
private BigDecimal useMoney;
/**
* 开通时间
*/
private Date openTime;
/**
* 上车时间（用于直通车投标）
*/
private Date onBusTime;
/**
* 排队序列号
*/
private Integer orderNum;
/**
* 借款标ID
*/
private Integer borrowId;
/**
* 借款标名称
*/
private String borrowName;
/**
* 借款标编号
*/
private String borrowContractNo;
/**
* 借款标发标时间
*/
private Date borrowPublishTime;
/**
* 标剩余金额（投之前此标剩余金额）
*/
private BigDecimal remaindMoney;
/**
* 实际投标金额（成功投标金额）
*/
private BigDecimal realAccount;
/**
* 状态【1：投标成功，2：未投标】
*/
private Integer status;
/**
* 插入时间
*/
private Date addTime;
/**
* 结果说明备注
*/
private String remark;
/**
* 版本号.
*/
private String version;
/**
* 本身版本号，主要用于根据版本号更新
*/
private String selfVersion;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public Integer getFirstBorrowId() {
return firstBorrowId;
}
public void setFirstBorrowId(Integer firstBorrowId) {
this.firstBorrowId = firstBorrowId;
}
public Integer getFirstTenderRealId() {
return firstTenderRealId;
}
public void setFirstTenderRealId(Integer firstTenderRealId) {
this.firstTenderRealId = firstTenderRealId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public BigDecimal getUseMoney() {
return useMoney;
}
public void setUseMoney(BigDecimal useMoney) {
this.useMoney = useMoney;
}
public Date getOpenTime() {
return openTime;
}
public void setOpenTime(Date openTime) {
this.openTime = openTime;
}
public Date getOnBusTime() {
return onBusTime;
}
public void setOnBusTime(Date onBusTime) {
this.onBusTime = onBusTime;
}
public Integer getOrderNum() {
return orderNum;
}
public void setOrderNum(Integer orderNum) {
this.orderNum = orderNum;
}
public Integer getBorrowId() {
return borrowId;
}
public void setBorrowId(Integer borrowId) {
this.borrowId = borrowId;
}
public String getBorrowName() {
return borrowName;
}
public void setBorrowName(String borrowName) {
this.borrowName = borrowName;
}
public String getBorrowContractNo() {
return borrowContractNo;
}
public void setBorrowContractNo(String borrowContractNo) {
this.borrowContractNo = borrowContractNo;
}
public Date getBorrowPublishTime() {
return borrowPublishTime;
}
public void setBorrowPublishTime(Date borrowPublishTime) {
this.borrowPublishTime = borrowPublishTime;
}
public BigDecimal getRemaindMoney() {
return remaindMoney;
}
public void setRemaindMoney(BigDecimal remaindMoney) {
this.remaindMoney = remaindMoney;
}
public BigDecimal getRealAccount() {
return realAccount;
}
public void setRealAccount(BigDecimal realAccount) {
this.realAccount = realAccount;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Date getAddTime() {
return addTime;
}
public void setAddTime(Date addTime) {
this.addTime = addTime;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getSelfVersion() {
return selfVersion;
}
public void setSelfVersion(String selfVersion) {
this.selfVersion = selfVersion;
}
}
| Lt19870723/console | src/com/cxdai/console/base/entity/FirstTenderLog.java | 1,484 | /**
* 排队序列号
*/ | block_comment | zh-cn | package com.cxdai.console.base.entity;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
*
* <p>
* Description:直通车投标日志记录<br />
* </p>
*
* @title FirstTenderLog.java
* @package com.cxdai.base.entity
* @author yangshijin
* @version 0.1 2015年3月11日
*/
public class FirstTenderLog implements Serializable {
private static final long serialVersionUID = 4829448266420311599L;
/**
* 主键Id
*/
private Integer id;
/**
* 直通车开通人ID
*/
private Integer userId;
/**
* 直通车ID
*/
private Integer firstBorrowId;
/**
* 直通车最终记录ID
*/
private Integer firstTenderRealId;
/**
* 用户名
*/
private String username;
/**
* 可用金额（投之前直通车可用余额）
*/
private BigDecimal useMoney;
/**
* 开通时间
*/
private Date openTime;
/**
* 上车时间（用于直通车投标）
*/
private Date onBusTime;
/**
* 排队序 <SUF>*/
private Integer orderNum;
/**
* 借款标ID
*/
private Integer borrowId;
/**
* 借款标名称
*/
private String borrowName;
/**
* 借款标编号
*/
private String borrowContractNo;
/**
* 借款标发标时间
*/
private Date borrowPublishTime;
/**
* 标剩余金额（投之前此标剩余金额）
*/
private BigDecimal remaindMoney;
/**
* 实际投标金额（成功投标金额）
*/
private BigDecimal realAccount;
/**
* 状态【1：投标成功，2：未投标】
*/
private Integer status;
/**
* 插入时间
*/
private Date addTime;
/**
* 结果说明备注
*/
private String remark;
/**
* 版本号.
*/
private String version;
/**
* 本身版本号，主要用于根据版本号更新
*/
private String selfVersion;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public Integer getFirstBorrowId() {
return firstBorrowId;
}
public void setFirstBorrowId(Integer firstBorrowId) {
this.firstBorrowId = firstBorrowId;
}
public Integer getFirstTenderRealId() {
return firstTenderRealId;
}
public void setFirstTenderRealId(Integer firstTenderRealId) {
this.firstTenderRealId = firstTenderRealId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public BigDecimal getUseMoney() {
return useMoney;
}
public void setUseMoney(BigDecimal useMoney) {
this.useMoney = useMoney;
}
public Date getOpenTime() {
return openTime;
}
public void setOpenTime(Date openTime) {
this.openTime = openTime;
}
public Date getOnBusTime() {
return onBusTime;
}
public void setOnBusTime(Date onBusTime) {
this.onBusTime = onBusTime;
}
public Integer getOrderNum() {
return orderNum;
}
public void setOrderNum(Integer orderNum) {
this.orderNum = orderNum;
}
public Integer getBorrowId() {
return borrowId;
}
public void setBorrowId(Integer borrowId) {
this.borrowId = borrowId;
}
public String getBorrowName() {
return borrowName;
}
public void setBorrowName(String borrowName) {
this.borrowName = borrowName;
}
public String getBorrowContractNo() {
return borrowContractNo;
}
public void setBorrowContractNo(String borrowContractNo) {
this.borrowContractNo = borrowContractNo;
}
public Date getBorrowPublishTime() {
return borrowPublishTime;
}
public void setBorrowPublishTime(Date borrowPublishTime) {
this.borrowPublishTime = borrowPublishTime;
}
public BigDecimal getRemaindMoney() {
return remaindMoney;
}
public void setRemaindMoney(BigDecimal remaindMoney) {
this.remaindMoney = remaindMoney;
}
public BigDecimal getRealAccount() {
return realAccount;
}
public void setRealAccount(BigDecimal realAccount) {
this.realAccount = realAccount;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Date getAddTime() {
return addTime;
}
public void setAddTime(Date addTime) {
this.addTime = addTime;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getSelfVersion() {
return selfVersion;
}
public void setSelfVersion(String selfVersion) {
this.selfVersion = selfVersion;
}
}
| true |
35011_1 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* LeetCode016
*
* Problem: 3Sum Closest
*
* 题目：最接近的三数之和
*
* Description: Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target.
* Return the sum of the three integers. You may assume that each input would have exactly one solution.
*
* 描述：给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。
* 返回这三个数的和。假定每组输入只存在唯一答案。
*
* Example:
* Given array nums = [-1, 2, 1, -4], and target = 1.
* The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
*
* 示例：
* 给定数组 nums = [-1，2，1，-4], 和 target = 1.
* 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
*/
public class LeetCode016 {
public static void main(String[] args) {
int[] nums = {-1, 2, 1, -4};
int target = 1;
int result = threeSumClosest(nums, target);
System.out.println(result);
}
public static int threeSumClosest(int[] nums, int target) {
int sum = 0;
int sub = 0;
int absSub = Integer.MAX_VALUE;
int len = nums.length;
// 从小到大排序
Arrays.sort(nums);
for (int i = 0; i < len; i++) {
int left = i+1;
int right = len - 1;
while (left<right) {
sub = nums[i]+nums[left]+nums[right] - target;
if (absSub>Math.abs(sub)) {
absSub = Math.abs(sub);
sum = nums[i]+nums[left]+nums[right];
}
if (sub>0) {
right--;
}else if(sub<0){
left++;
}else{
sum = nums[i]+nums[left]+nums[right];
break;
}
}
}
return sum;
}
} | LtLei/articles | leetcode/code/LeetCode016.java | 590 | // 从小到大排序 | line_comment | zh-cn | import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* LeetCode016
*
* Problem: 3Sum Closest
*
* 题目：最接近的三数之和
*
* Description: Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target.
* Return the sum of the three integers. You may assume that each input would have exactly one solution.
*
* 描述：给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。
* 返回这三个数的和。假定每组输入只存在唯一答案。
*
* Example:
* Given array nums = [-1, 2, 1, -4], and target = 1.
* The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
*
* 示例：
* 给定数组 nums = [-1，2，1，-4], 和 target = 1.
* 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
*/
public class LeetCode016 {
public static void main(String[] args) {
int[] nums = {-1, 2, 1, -4};
int target = 1;
int result = threeSumClosest(nums, target);
System.out.println(result);
}
public static int threeSumClosest(int[] nums, int target) {
int sum = 0;
int sub = 0;
int absSub = Integer.MAX_VALUE;
int len = nums.length;
// 从小 <SUF>
Arrays.sort(nums);
for (int i = 0; i < len; i++) {
int left = i+1;
int right = len - 1;
while (left<right) {
sub = nums[i]+nums[left]+nums[right] - target;
if (absSub>Math.abs(sub)) {
absSub = Math.abs(sub);
sum = nums[i]+nums[left]+nums[right];
}
if (sub>0) {
right--;
}else if(sub<0){
left++;
}else{
sum = nums[i]+nums[left]+nums[right];
break;
}
}
}
return sum;
}
} | true |
31845_1 | package guessnum;
import java.awt.Image;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
public class About extends javax.swing.JFrame {
//用 Java 调用windows系统的exe文件，比如notepad，calc之类
public static void openWinExe() {
Runtime rn = Runtime.getRuntime();
Process p = null;
try {
String command = "notepad";
p = rn.exec(command);
} catch (Exception e) {
System.out.println("Error win exec!");
}
}
//调用其他的可执行文件，例如：自己制作的exe，或是 下载 安装的软件.
public static void openExe(String process) {
Runtime rn = Runtime.getRuntime();
Process p = null;
try {
p = rn.exec(process);//如 "\"D:/QQ2010.exe\""，反斜杠加双引号用于显示双引号
} catch (Exception e) {
System.out.println("Error exec!");
}
}
public About() {
initComponents(); //选择初始化所有组件的方法，这里默认使用Netbeans生成的方法
// //修改窗口的咖啡图标？？不成功
// Toolkit tool=getToolkit();
// Image img=tool.getImage("/res/3.PNG");
// this.setIconImage(img);
//以上方法无效，使用以下方法...也无效，暂时放弃
ImageIcon ic = new ImageIcon("/res/3.png");
Image img = ic.getImage();
this.setIconImage(img);
}
//以initComponents()为基础修改的初始化程序段---已停用
private void MyInitComponents() {
dtt = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosed(java.awt.event.WindowEvent evt) {
AfterClose(evt);
}
public void windowClosing(java.awt.event.WindowEvent evt) {
closeAbout(evt);
}
});
dtt.setIcon(new javax.swing.ImageIcon(getClass().getResource("/res/2.jpg"))); // NOI18N
jLabel1.setFont(new java.awt.Font("宋体", 1, 18)); // NOI18N
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel1.setText("<html>\n本程序零技术含量，\n纯属作者本人无聊练手，\n因为很久没碰JAVA了\n短号：636484 \n企鹅：374607000");
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 98, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 271, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(19, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap(20, Short.MAX_VALUE)
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 111, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18))
.addGroup(layout.createSequentialGroup()
.addGap(29, 29, 29)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 91, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(29, Short.MAX_VALUE))
);
//一下设置居中显示，适应各种屏幕
java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-416)/2, (screenSize.height-181)/2, 416, 181);
}// </editor-fold>
// 两点注意事项：
//1. setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);应改为....DISPOSE_ON_CLOSE
//2. //以下两行代码设置居中显示，适应各种屏幕
/*java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();*/
/*setBounds((screenSize.width-342)/2, (screenSize.height-420)/2, 342, 420);*/
/*宽342，高408 实际填写值应稍大一些，如366和420*/
//现已调用initComponents()
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
dtt = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
jSeparator1 = new javax.swing.JSeparator();
jLabel2 = new javax.swing.JLabel();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
setTitle("关于Ltre的声明");
setResizable(false);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosed(java.awt.event.WindowEvent evt) {
AfterClose(evt);
}
public void windowClosing(java.awt.event.WindowEvent evt) {
closeAbout(evt);
}
});
dtt.setIcon(new javax.swing.ImageIcon(getClass().getResource("/res/2.jpg"))); // NOI18N
dtt.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toBrowser(evt);
}
});
jLabel1.setFont(new java.awt.Font("微软雅黑", 1, 14));
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel1.setText("<html>\n<center>鸣谢<br/>\n本程序零技术含量，纯属作者本人<br/>无聊练手，因为很久没碰JAVA了<br/>\n短号：636484 <br/>\n企鹅：374607000<br/>\n</center>\n</html>");
jLabel2.setBackground(new java.awt.Color(153, 102, 255));
jLabel2.setFont(new java.awt.Font("微软雅黑", 0, 12));
jLabel2.setText("<html>\n<center><font size=\"5\">version 1.5更新日志<br></font></center><br/>\n<center>相对1.2.0.0版本的更新明细</center><br>\n一、删除冗余函数GuessActionPerformed()<br/>\n二、注释暂时无用函数type_numActionPerformed()，日后添加新功能时再使用<br/>\n三、调整猜数次数显示的逻辑：<br/>\n （1）当dealGuess()返回false时，不显示当前猜数次数，而是显示警告；<br/>\n （2）当dealGuess()返回true时，表明成功判断，这时才在窗口底部显示当前猜数次数。<br/>\n四、修正第一次在输入框输入字符时就显示“到此为止，你已经猜了0次”的BUG。<br/>\n五、禁用JFrame最大化。<br/>\n六、去除窗体标题栏，窗口透明化。<br/>\n</html>");
jButton1.setBackground(new java.awt.Color(102, 102, 102));
jButton1.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton1.setText("Root");
jButton1.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toRoot(evt);
}
});
jButton2.setBackground(new java.awt.Color(102, 51, 255));
jButton2.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton2.setText("Iseo");
jButton2.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toIseo(evt);
}
});
jButton3.setBackground(new java.awt.Color(0, 153, 204));
jButton3.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton3.setText("KGJ");
jButton3.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toKGJ(evt);
}
});
jButton4.setBackground(new java.awt.Color(255, 102, 51));
jButton4.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton4.setText("FTP");
jButton4.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toFTP(evt);
}
});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 230, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 104, Short.MAX_VALUE))
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE, 223, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jButton4, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
.addComponent(jButton1, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
.addComponent(jButton2, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
.addComponent(jButton3, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)))
.addComponent(jSeparator1, javax.swing.GroupLayout.DEFAULT_SIZE, 338, Short.MAX_VALUE))
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE, 370, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED))
.addGroup(layout.createSequentialGroup()
.addComponent(jButton1, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(27, 27, 27)
.addComponent(jButton2, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(29, 29, 29)
.addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jButton4, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(10, 10, 10)))
.addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 12, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 117, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 108, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(99, 99, 99))
);
java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-374)/2, (screenSize.height-568)/2, 374, 568);
}// </editor-fold>//GEN-END:initComponents
private void closeAbout(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_closeAbout
this.setVisible(false);
this.dispose();
}//GEN-LAST:event_closeAbout
private void AfterClose(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_AfterClose
this.setVisible(false);
this.dispose();
}//GEN-LAST:event_AfterClose
private void toRoot(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toRoot
// try {
// Process p = Runtime.getRuntime().exec("iexplorer.exe http://www.baidu.com");
// }
// catch (IOException e1){
// e1.printStackTrace();
// }
//以上代码无法打开浏览器，并抛出异常，但是以下代码成功执行，前提是有安装IE
try{
Process net= Runtime.getRuntime().exec("explorer http://172.16.128.111/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
// openExe("jar://exe/36kB.exe");
//以下代码可能有效，但是抛出了异常
// String path = Object.class.getClassLoader().getResource("/exe36kB.exe").getFile();
// try {
// path = java.net.URLDecoder.decode(path, "utf-8");
// } catch (UnsupportedEncodingException ex) {
// Logger.getLogger(About.class.getName()).log(Level.SEVERE, null, ex);
// }
// try {
// Runtime.getRuntime().exec(path.substring(1));
// } catch (IOException ex) {
// Logger.getLogger(About.class.getName()).log(Level.SEVERE, null, ex);
// }
}//GEN-LAST:event_toRoot
private void toIseo(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toIseo
try{
Process net= Runtime.getRuntime().exec("explorer http://172.16.128.111/Iseo/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
}//GEN-LAST:event_toIseo
private void toKGJ(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toKGJ
try{
Process net= Runtime.getRuntime().exec("explorer http://172.16.128.111/test1-KingGuangJong/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
}//GEN-LAST:event_toKGJ
private void toFTP(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toFTP
try{
Process net= Runtime.getRuntime().exec("explorer ftp://qqqq:qqqq@172.16.128.111:21/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
}//GEN-LAST:event_toFTP
//点击狼鸟人后打开浏览器
private void toBrowser(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toBrowser
// Browser br = new Browser();
// br.setVisible(true);
}//GEN-LAST:event_toBrowser
public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
About ab = new About();
ab.setVisible(true);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton dtt;
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JSeparator jSeparator1;
// End of variables declaration//GEN-END:variables
}
| Ltre/GuessNum_1_5 | src/guessnum/About.java | 4,654 | //调用其他的可执行文件，例如：自己制作的exe，或是 下载 安装的软件. | line_comment | zh-cn | package guessnum;
import java.awt.Image;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
public class About extends javax.swing.JFrame {
//用 Java 调用windows系统的exe文件，比如notepad，calc之类
public static void openWinExe() {
Runtime rn = Runtime.getRuntime();
Process p = null;
try {
String command = "notepad";
p = rn.exec(command);
} catch (Exception e) {
System.out.println("Error win exec!");
}
}
//调用 <SUF>
public static void openExe(String process) {
Runtime rn = Runtime.getRuntime();
Process p = null;
try {
p = rn.exec(process);//如 "\"D:/QQ2010.exe\""，反斜杠加双引号用于显示双引号
} catch (Exception e) {
System.out.println("Error exec!");
}
}
public About() {
initComponents(); //选择初始化所有组件的方法，这里默认使用Netbeans生成的方法
// //修改窗口的咖啡图标？？不成功
// Toolkit tool=getToolkit();
// Image img=tool.getImage("/res/3.PNG");
// this.setIconImage(img);
//以上方法无效，使用以下方法...也无效，暂时放弃
ImageIcon ic = new ImageIcon("/res/3.png");
Image img = ic.getImage();
this.setIconImage(img);
}
//以initComponents()为基础修改的初始化程序段---已停用
private void MyInitComponents() {
dtt = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosed(java.awt.event.WindowEvent evt) {
AfterClose(evt);
}
public void windowClosing(java.awt.event.WindowEvent evt) {
closeAbout(evt);
}
});
dtt.setIcon(new javax.swing.ImageIcon(getClass().getResource("/res/2.jpg"))); // NOI18N
jLabel1.setFont(new java.awt.Font("宋体", 1, 18)); // NOI18N
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel1.setText("<html>\n本程序零技术含量，\n纯属作者本人无聊练手，\n因为很久没碰JAVA了\n短号：636484 \n企鹅：374607000");
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 98, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 271, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(19, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap(20, Short.MAX_VALUE)
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 111, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18))
.addGroup(layout.createSequentialGroup()
.addGap(29, 29, 29)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 91, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(29, Short.MAX_VALUE))
);
//一下设置居中显示，适应各种屏幕
java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-416)/2, (screenSize.height-181)/2, 416, 181);
}// </editor-fold>
// 两点注意事项：
//1. setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);应改为....DISPOSE_ON_CLOSE
//2. //以下两行代码设置居中显示，适应各种屏幕
/*java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();*/
/*setBounds((screenSize.width-342)/2, (screenSize.height-420)/2, 342, 420);*/
/*宽342，高408 实际填写值应稍大一些，如366和420*/
//现已调用initComponents()
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
dtt = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
jSeparator1 = new javax.swing.JSeparator();
jLabel2 = new javax.swing.JLabel();
jButton1 = new javax.swing.JButton();
jButton2 = new javax.swing.JButton();
jButton3 = new javax.swing.JButton();
jButton4 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
setTitle("关于Ltre的声明");
setResizable(false);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosed(java.awt.event.WindowEvent evt) {
AfterClose(evt);
}
public void windowClosing(java.awt.event.WindowEvent evt) {
closeAbout(evt);
}
});
dtt.setIcon(new javax.swing.ImageIcon(getClass().getResource("/res/2.jpg"))); // NOI18N
dtt.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toBrowser(evt);
}
});
jLabel1.setFont(new java.awt.Font("微软雅黑", 1, 14));
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel1.setText("<html>\n<center>鸣谢<br/>\n本程序零技术含量，纯属作者本人<br/>无聊练手，因为很久没碰JAVA了<br/>\n短号：636484 <br/>\n企鹅：374607000<br/>\n</center>\n</html>");
jLabel2.setBackground(new java.awt.Color(153, 102, 255));
jLabel2.setFont(new java.awt.Font("微软雅黑", 0, 12));
jLabel2.setText("<html>\n<center><font size=\"5\">version 1.5更新日志<br></font></center><br/>\n<center>相对1.2.0.0版本的更新明细</center><br>\n一、删除冗余函数GuessActionPerformed()<br/>\n二、注释暂时无用函数type_numActionPerformed()，日后添加新功能时再使用<br/>\n三、调整猜数次数显示的逻辑：<br/>\n （1）当dealGuess()返回false时，不显示当前猜数次数，而是显示警告；<br/>\n （2）当dealGuess()返回true时，表明成功判断，这时才在窗口底部显示当前猜数次数。<br/>\n四、修正第一次在输入框输入字符时就显示“到此为止，你已经猜了0次”的BUG。<br/>\n五、禁用JFrame最大化。<br/>\n六、去除窗体标题栏，窗口透明化。<br/>\n</html>");
jButton1.setBackground(new java.awt.Color(102, 102, 102));
jButton1.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton1.setText("Root");
jButton1.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toRoot(evt);
}
});
jButton2.setBackground(new java.awt.Color(102, 51, 255));
jButton2.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton2.setText("Iseo");
jButton2.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toIseo(evt);
}
});
jButton3.setBackground(new java.awt.Color(0, 153, 204));
jButton3.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton3.setText("KGJ");
jButton3.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toKGJ(evt);
}
});
jButton4.setBackground(new java.awt.Color(255, 102, 51));
jButton4.setFont(new java.awt.Font("微软雅黑", 1, 24));
jButton4.setText("FTP");
jButton4.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
toFTP(evt);
}
});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 230, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 104, Short.MAX_VALUE))
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE, 223, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jButton4, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
.addComponent(jButton1, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
.addComponent(jButton2, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)
.addComponent(jButton3, javax.swing.GroupLayout.DEFAULT_SIZE, 111, Short.MAX_VALUE)))
.addComponent(jSeparator1, javax.swing.GroupLayout.DEFAULT_SIZE, 338, Short.MAX_VALUE))
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE, 370, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED))
.addGroup(layout.createSequentialGroup()
.addComponent(jButton1, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(27, 27, 27)
.addComponent(jButton2, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(29, 29, 29)
.addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jButton4, javax.swing.GroupLayout.PREFERRED_SIZE, 71, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(10, 10, 10)))
.addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 12, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(dtt, javax.swing.GroupLayout.PREFERRED_SIZE, 117, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 108, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(99, 99, 99))
);
java.awt.Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-374)/2, (screenSize.height-568)/2, 374, 568);
}// </editor-fold>//GEN-END:initComponents
private void closeAbout(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_closeAbout
this.setVisible(false);
this.dispose();
}//GEN-LAST:event_closeAbout
private void AfterClose(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_AfterClose
this.setVisible(false);
this.dispose();
}//GEN-LAST:event_AfterClose
private void toRoot(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toRoot
// try {
// Process p = Runtime.getRuntime().exec("iexplorer.exe http://www.baidu.com");
// }
// catch (IOException e1){
// e1.printStackTrace();
// }
//以上代码无法打开浏览器，并抛出异常，但是以下代码成功执行，前提是有安装IE
try{
Process net= Runtime.getRuntime().exec("explorer http://172.16.128.111/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
// openExe("jar://exe/36kB.exe");
//以下代码可能有效，但是抛出了异常
// String path = Object.class.getClassLoader().getResource("/exe36kB.exe").getFile();
// try {
// path = java.net.URLDecoder.decode(path, "utf-8");
// } catch (UnsupportedEncodingException ex) {
// Logger.getLogger(About.class.getName()).log(Level.SEVERE, null, ex);
// }
// try {
// Runtime.getRuntime().exec(path.substring(1));
// } catch (IOException ex) {
// Logger.getLogger(About.class.getName()).log(Level.SEVERE, null, ex);
// }
}//GEN-LAST:event_toRoot
private void toIseo(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toIseo
try{
Process net= Runtime.getRuntime().exec("explorer http://172.16.128.111/Iseo/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
}//GEN-LAST:event_toIseo
private void toKGJ(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toKGJ
try{
Process net= Runtime.getRuntime().exec("explorer http://172.16.128.111/test1-KingGuangJong/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
}//GEN-LAST:event_toKGJ
private void toFTP(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toFTP
try{
Process net= Runtime.getRuntime().exec("explorer ftp://qqqq:qqqq@172.16.128.111:21/");
}
catch(Exception e){
System.out.println("Error!");
JOptionPane.showMessageDialog(null, e.getMessage());
}
}//GEN-LAST:event_toFTP
//点击狼鸟人后打开浏览器
private void toBrowser(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_toBrowser
// Browser br = new Browser();
// br.setVisible(true);
}//GEN-LAST:event_toBrowser
public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(About.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
About ab = new About();
ab.setVisible(true);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton dtt;
private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JSeparator jSeparator1;
// End of variables declaration//GEN-END:variables
}
| true |
54060_0 | package org.luvx.pattern.creational.builder.a;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.luvx.pattern.creational.builder.Car;
/**
* 该类也可以合并到Buidler抽象类中去
* 在抽象类中提供静态build方法构想复杂对象
*/
@NoArgsConstructor
@AllArgsConstructor
public class Director {
@Setter
private Builder builder;
public Car build() {
builder.wheels("4个轮子")
.engine("宝马引擎");
if (!builder.isConvertible()) {
builder.sail("玛莎拉蒂车棚");
}
return builder.build();
}
public Car build1(Builder builder) {
builder.wheels("4个轮子")
.engine("宝马引擎");
if (!builder.isConvertible()) {
builder.sail("玛莎拉蒂车棚");
}
return builder.build();
}
}
| LuVx21/coding-usage | usage-case/pattern/src/main/java/org/luvx/pattern/creational/builder/a/Director.java | 241 | /**
* 该类也可以合并到Buidler抽象类中去
* 在抽象类中提供静态build方法构想复杂对象
*/ | block_comment | zh-cn | package org.luvx.pattern.creational.builder.a;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.Setter;
import org.luvx.pattern.creational.builder.Car;
/**
* 该类也 <SUF>*/
@NoArgsConstructor
@AllArgsConstructor
public class Director {
@Setter
private Builder builder;
public Car build() {
builder.wheels("4个轮子")
.engine("宝马引擎");
if (!builder.isConvertible()) {
builder.sail("玛莎拉蒂车棚");
}
return builder.build();
}
public Car build1(Builder builder) {
builder.wheels("4个轮子")
.engine("宝马引擎");
if (!builder.isConvertible()) {
builder.sail("玛莎拉蒂车棚");
}
return builder.build();
}
}
| true |
22945_8 | import java.io.IOException;
import java.io.InputStream;
/**
* 提供允许系统命令行并提供返回值
*/
public class CommandLine {
private static void readStream(InputStream inputStream, StringBuilder builder) {
byte[] buff = new byte[4096];
int len;
try {
while (-1 != (len = inputStream.read(buff, 0, buff.length))) {
builder.append(new String(buff, 0, len));
}
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 同步执行指定的命令，并在标准输出流中输出日志信息
*
* @param command 命令
* @return 执行结果
*/
public static String run(String command) {
return run(command, true);
}
/**
* 同步执行指定的命令
*
* @param command 命令
* @param log 是否输入日志
* @return 执行结果
*/
public static String run(String command, boolean log) {
// StringBuilder 非线程安全，因此一旦传递给线程中，就不要再次使用
// 若子线程与父线程需要同时使用，需使用StringBuffer，为线程安全
StringBuilder builderInfo = new StringBuilder(); // 正常信息
StringBuilder builderErr = new StringBuilder(); // 错误信息
try {
if (log) {
System.out.println("Invoked -> " + command);
}
Process process = Runtime.getRuntime().exec(command);
// 启动两个线程读取输入流与错误输入流，防止程序死锁
Thread threadInfo = new Thread(() -> readStream(process.getInputStream(), builderInfo));
// 读取错误信息
Thread threadErr = new Thread(() -> readStream(process.getErrorStream(), builderErr));
threadInfo.start();
threadErr.start();
int exitValue = process.waitFor();
if (exitValue != 0) {
System.out.println("Invoked Err ReturnValue -> " + exitValue);
while (threadErr.getState() != Thread.State.TERMINATED)
Thread.sleep(50); //等待读取线程完毕
System.out.println(builderErr.toString());
}
// 等待线程读取完毕
while (threadInfo.getState() != Thread.State.TERMINATED)
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return builderInfo.toString();
}
}
| Lua12138/UtilsClass | locals/CommandLine.java | 567 | // 读取错误信息 | line_comment | zh-cn | import java.io.IOException;
import java.io.InputStream;
/**
* 提供允许系统命令行并提供返回值
*/
public class CommandLine {
private static void readStream(InputStream inputStream, StringBuilder builder) {
byte[] buff = new byte[4096];
int len;
try {
while (-1 != (len = inputStream.read(buff, 0, buff.length))) {
builder.append(new String(buff, 0, len));
}
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 同步执行指定的命令，并在标准输出流中输出日志信息
*
* @param command 命令
* @return 执行结果
*/
public static String run(String command) {
return run(command, true);
}
/**
* 同步执行指定的命令
*
* @param command 命令
* @param log 是否输入日志
* @return 执行结果
*/
public static String run(String command, boolean log) {
// StringBuilder 非线程安全，因此一旦传递给线程中，就不要再次使用
// 若子线程与父线程需要同时使用，需使用StringBuffer，为线程安全
StringBuilder builderInfo = new StringBuilder(); // 正常信息
StringBuilder builderErr = new StringBuilder(); // 错误信息
try {
if (log) {
System.out.println("Invoked -> " + command);
}
Process process = Runtime.getRuntime().exec(command);
// 启动两个线程读取输入流与错误输入流，防止程序死锁
Thread threadInfo = new Thread(() -> readStream(process.getInputStream(), builderInfo));
// 读取 <SUF>
Thread threadErr = new Thread(() -> readStream(process.getErrorStream(), builderErr));
threadInfo.start();
threadErr.start();
int exitValue = process.waitFor();
if (exitValue != 0) {
System.out.println("Invoked Err ReturnValue -> " + exitValue);
while (threadErr.getState() != Thread.State.TERMINATED)
Thread.sleep(50); //等待读取线程完毕
System.out.println(builderErr.toString());
}
// 等待线程读取完毕
while (threadInfo.getState() != Thread.State.TERMINATED)
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return builderInfo.toString();
}
}
| true |
41073_18 | package dev.bnna.androlua;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.Gravity;
import android.view.View;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import org.keplerproject.luajava.LuaState;
import org.keplerproject.luajava.LuaStateFactory;
import dev.bnna.androlua.utils.Constant;
import dev.bnna.androlua.utils.FileUtil;
import dev.bnna.androlua.utils.NetUtil;
public class CustomViewActivity extends Activity {
final int MARGIN = 10;
public LuaState mLuaState;
public static final String TAG = "Lua";
private static final int TITLE = 1000;
private static final int SUB_TITLE = 2000;
public LinearLayout linearLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setLuaView();
// linearLayout.addView(rectHView(this,"电影",1000,"伦敦",R.drawable.icon,true));
// linearLayout.addView(rectVView(this,"电影",2000,"伦敦",R.drawable.icon,true));
// linearLayout.addView(rectPercentView(this,"电影",2000,"伦敦",R.drawable.icon,true));
// setPercentView();
}
private void setLuaView() {
setContentView(R.layout.customview_activity);
long startTime = System.currentTimeMillis();
mLuaState = LuaStateFactory.newLuaState();
mLuaState.openLibs();
linearLayout = (LinearLayout) this.findViewById(R.id.custom_view);
// getScreen(Constant.VIEW,"getScreen");
//// linearLayout.setOrientation(LinearLayout.HORIZONTAL);
addLuaView(linearLayout, Constant.VIEW,"mainView");
// long endTime = System.currentTimeMillis();
// Log.e(TAG, "onCreate: "+(endTime-startTime));
}
private void getScreen(final String path,final String function) {
new Thread(){
@Override
public void run() {
super.run();
final String str = NetUtil.getString(path);
//
// runOnUiThread(new Runnable() {
// @Override
// public void run() {
DisplayMetrics metrics = new DisplayMetrics();
WindowManager WM = (WindowManager) CustomViewActivity.this.getSystemService(Context.WINDOW_SERVICE);
Display display = WM.getDefaultDisplay();
display.getMetrics(metrics);
int height = metrics.heightPixels; // 屏幕高
int width = metrics.widthPixels; // 屏幕的宽
int scale = (int)getResources().getDisplayMetrics().density;
Log.e(TAG, "getDisplay: width/height/scale "+width +"/"+height +"/"+scale);
long startTime = System.currentTimeMillis();
// Log.e(TAG, "str: "+str);
if (str == null) {
mLuaState.LdoString(FileUtil.readStreamFromAssets(CustomViewActivity.this,"view.lua"));
}else {
mLuaState.LdoString(str);
}
mLuaState.getField(LuaState.LUA_GLOBALSINDEX,function);
mLuaState.pushJavaObject(getApplicationContext());// 第一个参数 context
mLuaState.pushJavaObject(scale);// 第二个参数， Layout
mLuaState.pushJavaObject(width);// 第二个参数， Layout
mLuaState.pushJavaObject(height);// 第二个参数， Layout
mLuaState.call(4, 0);// 2个参数，0个返回值
}
// });
// }
}.start();
}
public void luaButton(View v){
// linearLayout.removeAllViews();
addLuaView(linearLayout,Constant.VIEW,"rectView");
Toast.makeText(CustomViewActivity.this, "luaButton", Toast.LENGTH_SHORT).show();
}
private void setPercentView() {
// setContentView(R.layout.percent_view);
// PercentRelativeLayout relativeLayout = (PercentRelativeLayout) findViewById(R.id.percentile_view);
//
// PercentRelativeLayout.LayoutParams layoutParams = (PercentRelativeLayout.LayoutParams) relativeLayout.getLayoutParams();
//
// PercentLayoutHelper.PercentLayoutInfo percentLayoutInfo = layoutParams.getPercentLayoutInfo();
// percentLayoutInfo.leftMarginPercent = 15 * 0.01f; //15 is the percentage value you want to set it to
// relativeLayout.setLayoutParams(layoutParams);
// relativeLayout.requestLayout();
// try {
// relativeLayout.addView(rectPercentView(this,"电影",2000,"伦敦",R.drawable.icon,true));
// } catch (IOException e) {
// e.printStackTrace();
// }
}
public void addLuaView(final LinearLayout linearLayout,final String path,final String function){
long startTime = System.currentTimeMillis();
new Thread(){
@Override
public void run() {
super.run();
final String str = NetUtil.getString(path);
//
runOnUiThread(new Runnable() {
@Override
public void run() {
long startTime = System.currentTimeMillis();
// Log.e(TAG, "str: "+str);
if (str == null) {
mLuaState.LdoString(FileUtil.readStreamFromAssets(CustomViewActivity.this,"view.lua"));
}else {
mLuaState.LdoString(str);
}
long endTime = System.currentTimeMillis();
Log.e(TAG, "doString: "+(endTime-startTime));
mLuaState.getField(LuaState.LUA_GLOBALSINDEX,function);
mLuaState.pushJavaObject(getApplicationContext());// 第一个参数 context
mLuaState.pushJavaObject(linearLayout);// 第二个参数， Layout
mLuaState.call(2, 0);// 2个参数，0个返回值
}
});
}
}.start();
long endTime = System.currentTimeMillis();
Log.e(TAG, "runOnUiThread: "+(endTime - startTime));
}
private LinearLayout mainView(Context context){
LinearLayout linearLayout = new LinearLayout(context);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
linearLayout.setOrientation(LinearLayout.HORIZONTAL);
linearLayout.setGravity(Gravity.CENTER_HORIZONTAL);
linearLayout.setLayoutParams(layoutParams);
linearLayout.addView(viewWithText(context,R.drawable.ic_choose_title,"会员抢购不限时","新辣道","Y81.5",R.drawable.ic_specials));
linearLayout.addView(viewWithOneIcon(context,R.drawable.ic_store_title,"到店支付五折起",R.drawable.ic_store_pic));
linearLayout.addView(viewWithOneIcon(context,R.drawable.ic_store_title,"到店支付五折起",R.drawable.ic_store_pic));
return linearLayout;
}
/**
* 包含特价的View
* @param context context
* @param titlePic 标题图片
* @param subTitleText 副标题文本
* @param specialTitle 特价标题
* @param specialText 特价内容
* @return
*/
private LinearLayout viewWithText(Context context,int titlePic,String subTitleText,String specialTitle,String specialText,int specialTextPic){
LinearLayout linearLayout = new LinearLayout(context);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT,1);
layoutParams.gravity = Gravity.CENTER_HORIZONTAL;
layoutParams.setMargins(MARGIN,MARGIN,MARGIN,MARGIN);
layoutParams.gravity = Gravity.BOTTOM;
// layoutParams.
linearLayout.setOrientation(LinearLayout.VERTICAL);
linearLayout.setLayoutParams(layoutParams);
linearLayout.setBackgroundColor(Color.LTGRAY);
Bitmap bitmap = BitmapFactory.decodeFile(FileUtil.getSDCARDFilePath("icon.png"));
// titlePic
ImageView titleImg = new ImageView(context);
// titleImg.setImageResource(titlePic);
titleImg.setImageBitmap(bitmap);
//subTitleText
TextView subTitleTv = new TextView(context);
subTitleTv.setText(subTitleText);
subTitleTv.setTextColor(Color.BLACK);
subTitleTv.setGravity(Gravity.CENTER_HORIZONTAL);
//subTitleText
TextView specialTitleTV = new TextView(context);
specialTitleTV.setText(specialTitle);
specialTitleTV.setTextColor(Color.BLACK);
specialTitleTV.setGravity(Gravity.CENTER_HORIZONTAL);
//subTitleText
TextView specialTextTv = new TextView(context);
specialTextTv.setText(specialText);
specialTextTv.setTextColor(Color.RED);
specialTextTv.setGravity(Gravity.CENTER_HORIZONTAL);
Drawable drawable = context.getResources().getDrawable(specialTextPic);
specialTextTv.setCompoundDrawablesWithIntrinsicBounds(null,null,drawable,null);
drawable.setBounds(0, 0, drawable.getMinimumWidth(), drawable.getMinimumHeight());//必须设置图片大小，否则不显示
// specialTextTv.setCompoundDrawables(null,null,drawable,null);
specialTextTv.setGravity(Gravity.CENTER_HORIZONTAL);
// add view
linearLayout.addView(titleImg);
linearLayout.addView(subTitleTv);
linearLayout.addView(specialTitleTV);
linearLayout.addView(specialTextTv);
return linearLayout;
}
/**
* 包含一个标题，一个副标题，一个主图的View
* @param context context
* @param titlePic 标题图片
* @param subTitleText 副标题文本
* @param mainPic 主图
* @return
*/
private LinearLayout viewWithOneIcon(Context context,int titlePic,String subTitleText,int mainPic){
LinearLayout linearLayout = new LinearLayout(context);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT,1);
linearLayout.setOrientation(LinearLayout.VERTICAL);
linearLayout.setGravity(Gravity.HORIZONTAL_GRAVITY_MASK);
linearLayout.setLayoutParams(layoutParams);
linearLayout.setBackgroundColor(Color.LTGRAY);
layoutParams.setMargins(MARGIN,MARGIN,MARGIN,MARGIN);
// titlePic
ImageView titleImg = new ImageView(context);
titleImg.setImageResource(titlePic);
//subtitle
TextView subTitleTv = new TextView(context);
subTitleTv.setText(subTitleText);
subTitleTv.setGravity(Gravity.CENTER_HORIZONTAL);
//mainPic
ImageView mainImg = new ImageView(context);
mainImg.setImageResource(mainPic);
linearLayout.addView(titleImg);
linearLayout.addView(subTitleTv);
linearLayout.addView(mainImg);
return linearLayout;
}
/**
* 豆腐块
* @param context context
* @param title
* @param subTitle
* @param icon
* @param special
*/
@SuppressWarnings("ResourceType")
public RelativeLayout rectVView(Context context, String title,int titleId, String subTitle, int icon, boolean special){
RelativeLayout relativeLayout = new RelativeLayout(context);
relativeLayout.setBackgroundColor(Color.WHITE);
// RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(400,600);
relativeLayout.setLayoutParams(layoutParams);
TextView titleTv = new TextView(context);
titleTv.setText(title);
titleTv.setTextColor(Color.BLUE);
titleTv.setId(titleId);
layoutParams.addRule(RelativeLayout.ALIGN_LEFT);
TextView subTitleTv = new TextView(context);
int subTitleId = titleId + 100;
subTitleTv.setText(subTitle);
subTitleTv.setTextColor(Color.RED);
layoutParams.addRule(RelativeLayout.RIGHT_OF,titleId);
RelativeLayout.LayoutParams ivParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
ImageView iconIv = new ImageView(context);
iconIv.setImageResource(icon);
ivParams.addRule(RelativeLayout.BELOW,subTitleId);
ivParams.addRule(RelativeLayout.CENTER_VERTICAL|RelativeLayout.ALIGN_LEFT);
ivParams.addRule(RelativeLayout.ALIGN_RIGHT);
relativeLayout.addView(titleTv);
relativeLayout.addView(subTitleTv,layoutParams);
relativeLayout.addView(iconIv,ivParams);
View view = new View(context);
return relativeLayout;
}
public RelativeLayout rectHView(Context context, String title,int titleId, String subTitle, int icon, boolean special){
RelativeLayout relativeLayout = new RelativeLayout(context);
relativeLayout.setBackgroundColor(Color.WHITE);
// RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(500,500);
relativeLayout.setLayoutParams(layoutParams);
TextView titleTv = new TextView(context);
titleTv.setText(title);
titleTv.setTextColor(Color.BLUE);
titleTv.setId(titleId);
TextView subTitleTv = new TextView(context);
subTitleTv.setText(subTitle);
subTitleTv.setTextColor(Color.RED);
layoutParams.addRule(RelativeLayout.BELOW,titleId);
RelativeLayout.LayoutParams ivParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
ImageView iconIv = new ImageView(context);
iconIv.setImageResource(icon);
ivParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
ivParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
relativeLayout.addView(titleTv);
relativeLayout.addView(subTitleTv,layoutParams);
relativeLayout.addView(iconIv,ivParams);
return relativeLayout;
}
// public PercentRelativeLayout rectPercentView(Context context, String title,int titleId, String subTitle, int icon, boolean special) throws IOException {
// XmlPullParser parser = Xml.newPullParser();
// try {
// parser.setInput(context.getAssets().open("percent_view.xml"), "UTF-8");// 设置数据源编码
// } catch (XmlPullParserException e) {
// e.printStackTrace();
// }
// XmlPullParser parser = getResources().getXml(R.xml.attrs);
// AttributeSet attrs = Xml.asAttributeSet(parser);
// PercentRelativeLayout relativeLayout = new PercentRelativeLayout(context,attrs);
// relativeLayout.setBackgroundColor(Color.WHITE);
// PercentRelativeLayout.LayoutParams layoutParams = new PercentRelativeLayout.LayoutParams(100,100);
// PercentRelativeLayout.LayoutParams layoutParams = new PercentRelativeLayout.LayoutParams(context,attrs);
// relativeLayout.setLayoutParams(layoutParams);
// TypedArray typeArray = context.obtainStyledAttributes(attrs,
// R.styleable.PercentLayout_Layout);
// layoutParams.setBaseAttributes(typeArray,50,50);
//PercentRelativeLayout relativeLayout = new PercentRelativeLayout(context);
// PercentRelativeLayout.LayoutParams params = (PercentRelativeLayout.LayoutParams) relativeLayout.getLayoutParams();
//// This will currently return null, if it was not constructed from XML.
// PercentLayoutHelper.PercentLayoutInfo info = params.getPercentLayoutInfo();
// info.heightPercent = 0.60f;
// relativeLayout.requestLayout();
// PercentRelativeLayout relativeLayout = new PercentRelativeLayout(context);
// relativeLayout.setBackgroundColor(Color.WHITE);
// PercentRelativeLayout.LayoutParams layoutParams = new PercentRelativeLayout.LayoutParams(500,500);
// relativeLayout.setLayoutParams(layoutParams);
// 百分比
// RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
//// layoutParams.addRule(PercentRelativeLayout);
// TextView titleTv = new TextView(context);
//// titleTv.set
// titleTv.setText(title);
// titleTv.setTextColor(Color.BLUE);
// titleTv.setId(titleId);
// titleTv.setBackgroundColor(Color.YELLOW);
// PercentRelativeLayout.LayoutParams tvPramas = new PercentRelativeLayout.LayoutParams(500,500);
//// (PercentRelativeLayout.LayoutParams) titleTv.getLayoutParams();
////
// layoutParams.la
// PercentLayoutHelper.PercentLayoutInfo info = layoutParams.getPercentLayoutInfo();
// info.widthPercent = 0.80f;
// info.heightPercent = 0.50f;
// titleTv.requestLayout();
//
// TextView subTitleTv = new TextView(context);
// subTitleTv.setText(subTitle);
// subTitleTv.setTextColor(Color.RED);
// PercentRelativeLayout.LayoutParams subTitleTvParams = new PercentRelativeLayout.LayoutParams(PercentRelativeLayout.LayoutParams.WRAP_CONTENT,PercentRelativeLayout.LayoutParams.WRAP_CONTENT);
// subTitleTvParams.addRule(PercentRelativeLayout.BELOW,titleId);
//
//
//
// RelativeLayout.LayoutParams ivParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
// ImageView iconIv = new ImageView(context);
//
// iconIv.setImageResource(icon);
// ivParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
// ivParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
//
//// relativeLayout.addView(titleTv,tvPramas);
//// relativeLayout.addView(subTitleTv,subTitleTvParams);
//// relativeLayout.addView(iconIv,ivParams);
//// relativeLayout.requestLayout();
// return relativeLayout;
//
// }
}
| LuaAndroid/LuaAndroid | app/src/dev/bnna/androlua/CustomViewActivity.java | 4,373 | // 2个参数，0个返回值 | line_comment | zh-cn | package dev.bnna.androlua;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.Gravity;
import android.view.View;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import org.keplerproject.luajava.LuaState;
import org.keplerproject.luajava.LuaStateFactory;
import dev.bnna.androlua.utils.Constant;
import dev.bnna.androlua.utils.FileUtil;
import dev.bnna.androlua.utils.NetUtil;
public class CustomViewActivity extends Activity {
final int MARGIN = 10;
public LuaState mLuaState;
public static final String TAG = "Lua";
private static final int TITLE = 1000;
private static final int SUB_TITLE = 2000;
public LinearLayout linearLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setLuaView();
// linearLayout.addView(rectHView(this,"电影",1000,"伦敦",R.drawable.icon,true));
// linearLayout.addView(rectVView(this,"电影",2000,"伦敦",R.drawable.icon,true));
// linearLayout.addView(rectPercentView(this,"电影",2000,"伦敦",R.drawable.icon,true));
// setPercentView();
}
private void setLuaView() {
setContentView(R.layout.customview_activity);
long startTime = System.currentTimeMillis();
mLuaState = LuaStateFactory.newLuaState();
mLuaState.openLibs();
linearLayout = (LinearLayout) this.findViewById(R.id.custom_view);
// getScreen(Constant.VIEW,"getScreen");
//// linearLayout.setOrientation(LinearLayout.HORIZONTAL);
addLuaView(linearLayout, Constant.VIEW,"mainView");
// long endTime = System.currentTimeMillis();
// Log.e(TAG, "onCreate: "+(endTime-startTime));
}
private void getScreen(final String path,final String function) {
new Thread(){
@Override
public void run() {
super.run();
final String str = NetUtil.getString(path);
//
// runOnUiThread(new Runnable() {
// @Override
// public void run() {
DisplayMetrics metrics = new DisplayMetrics();
WindowManager WM = (WindowManager) CustomViewActivity.this.getSystemService(Context.WINDOW_SERVICE);
Display display = WM.getDefaultDisplay();
display.getMetrics(metrics);
int height = metrics.heightPixels; // 屏幕高
int width = metrics.widthPixels; // 屏幕的宽
int scale = (int)getResources().getDisplayMetrics().density;
Log.e(TAG, "getDisplay: width/height/scale "+width +"/"+height +"/"+scale);
long startTime = System.currentTimeMillis();
// Log.e(TAG, "str: "+str);
if (str == null) {
mLuaState.LdoString(FileUtil.readStreamFromAssets(CustomViewActivity.this,"view.lua"));
}else {
mLuaState.LdoString(str);
}
mLuaState.getField(LuaState.LUA_GLOBALSINDEX,function);
mLuaState.pushJavaObject(getApplicationContext());// 第一个参数 context
mLuaState.pushJavaObject(scale);// 第二个参数， Layout
mLuaState.pushJavaObject(width);// 第二个参数， Layout
mLuaState.pushJavaObject(height);// 第二个参数， Layout
mLuaState.call(4, 0);// 2个 <SUF>
}
// });
// }
}.start();
}
public void luaButton(View v){
// linearLayout.removeAllViews();
addLuaView(linearLayout,Constant.VIEW,"rectView");
Toast.makeText(CustomViewActivity.this, "luaButton", Toast.LENGTH_SHORT).show();
}
private void setPercentView() {
// setContentView(R.layout.percent_view);
// PercentRelativeLayout relativeLayout = (PercentRelativeLayout) findViewById(R.id.percentile_view);
//
// PercentRelativeLayout.LayoutParams layoutParams = (PercentRelativeLayout.LayoutParams) relativeLayout.getLayoutParams();
//
// PercentLayoutHelper.PercentLayoutInfo percentLayoutInfo = layoutParams.getPercentLayoutInfo();
// percentLayoutInfo.leftMarginPercent = 15 * 0.01f; //15 is the percentage value you want to set it to
// relativeLayout.setLayoutParams(layoutParams);
// relativeLayout.requestLayout();
// try {
// relativeLayout.addView(rectPercentView(this,"电影",2000,"伦敦",R.drawable.icon,true));
// } catch (IOException e) {
// e.printStackTrace();
// }
}
public void addLuaView(final LinearLayout linearLayout,final String path,final String function){
long startTime = System.currentTimeMillis();
new Thread(){
@Override
public void run() {
super.run();
final String str = NetUtil.getString(path);
//
runOnUiThread(new Runnable() {
@Override
public void run() {
long startTime = System.currentTimeMillis();
// Log.e(TAG, "str: "+str);
if (str == null) {
mLuaState.LdoString(FileUtil.readStreamFromAssets(CustomViewActivity.this,"view.lua"));
}else {
mLuaState.LdoString(str);
}
long endTime = System.currentTimeMillis();
Log.e(TAG, "doString: "+(endTime-startTime));
mLuaState.getField(LuaState.LUA_GLOBALSINDEX,function);
mLuaState.pushJavaObject(getApplicationContext());// 第一个参数 context
mLuaState.pushJavaObject(linearLayout);// 第二个参数， Layout
mLuaState.call(2, 0);// 2个参数，0个返回值
}
});
}
}.start();
long endTime = System.currentTimeMillis();
Log.e(TAG, "runOnUiThread: "+(endTime - startTime));
}
private LinearLayout mainView(Context context){
LinearLayout linearLayout = new LinearLayout(context);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
linearLayout.setOrientation(LinearLayout.HORIZONTAL);
linearLayout.setGravity(Gravity.CENTER_HORIZONTAL);
linearLayout.setLayoutParams(layoutParams);
linearLayout.addView(viewWithText(context,R.drawable.ic_choose_title,"会员抢购不限时","新辣道","Y81.5",R.drawable.ic_specials));
linearLayout.addView(viewWithOneIcon(context,R.drawable.ic_store_title,"到店支付五折起",R.drawable.ic_store_pic));
linearLayout.addView(viewWithOneIcon(context,R.drawable.ic_store_title,"到店支付五折起",R.drawable.ic_store_pic));
return linearLayout;
}
/**
* 包含特价的View
* @param context context
* @param titlePic 标题图片
* @param subTitleText 副标题文本
* @param specialTitle 特价标题
* @param specialText 特价内容
* @return
*/
private LinearLayout viewWithText(Context context,int titlePic,String subTitleText,String specialTitle,String specialText,int specialTextPic){
LinearLayout linearLayout = new LinearLayout(context);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT,1);
layoutParams.gravity = Gravity.CENTER_HORIZONTAL;
layoutParams.setMargins(MARGIN,MARGIN,MARGIN,MARGIN);
layoutParams.gravity = Gravity.BOTTOM;
// layoutParams.
linearLayout.setOrientation(LinearLayout.VERTICAL);
linearLayout.setLayoutParams(layoutParams);
linearLayout.setBackgroundColor(Color.LTGRAY);
Bitmap bitmap = BitmapFactory.decodeFile(FileUtil.getSDCARDFilePath("icon.png"));
// titlePic
ImageView titleImg = new ImageView(context);
// titleImg.setImageResource(titlePic);
titleImg.setImageBitmap(bitmap);
//subTitleText
TextView subTitleTv = new TextView(context);
subTitleTv.setText(subTitleText);
subTitleTv.setTextColor(Color.BLACK);
subTitleTv.setGravity(Gravity.CENTER_HORIZONTAL);
//subTitleText
TextView specialTitleTV = new TextView(context);
specialTitleTV.setText(specialTitle);
specialTitleTV.setTextColor(Color.BLACK);
specialTitleTV.setGravity(Gravity.CENTER_HORIZONTAL);
//subTitleText
TextView specialTextTv = new TextView(context);
specialTextTv.setText(specialText);
specialTextTv.setTextColor(Color.RED);
specialTextTv.setGravity(Gravity.CENTER_HORIZONTAL);
Drawable drawable = context.getResources().getDrawable(specialTextPic);
specialTextTv.setCompoundDrawablesWithIntrinsicBounds(null,null,drawable,null);
drawable.setBounds(0, 0, drawable.getMinimumWidth(), drawable.getMinimumHeight());//必须设置图片大小，否则不显示
// specialTextTv.setCompoundDrawables(null,null,drawable,null);
specialTextTv.setGravity(Gravity.CENTER_HORIZONTAL);
// add view
linearLayout.addView(titleImg);
linearLayout.addView(subTitleTv);
linearLayout.addView(specialTitleTV);
linearLayout.addView(specialTextTv);
return linearLayout;
}
/**
* 包含一个标题，一个副标题，一个主图的View
* @param context context
* @param titlePic 标题图片
* @param subTitleText 副标题文本
* @param mainPic 主图
* @return
*/
private LinearLayout viewWithOneIcon(Context context,int titlePic,String subTitleText,int mainPic){
LinearLayout linearLayout = new LinearLayout(context);
LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT,1);
linearLayout.setOrientation(LinearLayout.VERTICAL);
linearLayout.setGravity(Gravity.HORIZONTAL_GRAVITY_MASK);
linearLayout.setLayoutParams(layoutParams);
linearLayout.setBackgroundColor(Color.LTGRAY);
layoutParams.setMargins(MARGIN,MARGIN,MARGIN,MARGIN);
// titlePic
ImageView titleImg = new ImageView(context);
titleImg.setImageResource(titlePic);
//subtitle
TextView subTitleTv = new TextView(context);
subTitleTv.setText(subTitleText);
subTitleTv.setGravity(Gravity.CENTER_HORIZONTAL);
//mainPic
ImageView mainImg = new ImageView(context);
mainImg.setImageResource(mainPic);
linearLayout.addView(titleImg);
linearLayout.addView(subTitleTv);
linearLayout.addView(mainImg);
return linearLayout;
}
/**
* 豆腐块
* @param context context
* @param title
* @param subTitle
* @param icon
* @param special
*/
@SuppressWarnings("ResourceType")
public RelativeLayout rectVView(Context context, String title,int titleId, String subTitle, int icon, boolean special){
RelativeLayout relativeLayout = new RelativeLayout(context);
relativeLayout.setBackgroundColor(Color.WHITE);
// RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(400,600);
relativeLayout.setLayoutParams(layoutParams);
TextView titleTv = new TextView(context);
titleTv.setText(title);
titleTv.setTextColor(Color.BLUE);
titleTv.setId(titleId);
layoutParams.addRule(RelativeLayout.ALIGN_LEFT);
TextView subTitleTv = new TextView(context);
int subTitleId = titleId + 100;
subTitleTv.setText(subTitle);
subTitleTv.setTextColor(Color.RED);
layoutParams.addRule(RelativeLayout.RIGHT_OF,titleId);
RelativeLayout.LayoutParams ivParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
ImageView iconIv = new ImageView(context);
iconIv.setImageResource(icon);
ivParams.addRule(RelativeLayout.BELOW,subTitleId);
ivParams.addRule(RelativeLayout.CENTER_VERTICAL|RelativeLayout.ALIGN_LEFT);
ivParams.addRule(RelativeLayout.ALIGN_RIGHT);
relativeLayout.addView(titleTv);
relativeLayout.addView(subTitleTv,layoutParams);
relativeLayout.addView(iconIv,ivParams);
View view = new View(context);
return relativeLayout;
}
public RelativeLayout rectHView(Context context, String title,int titleId, String subTitle, int icon, boolean special){
RelativeLayout relativeLayout = new RelativeLayout(context);
relativeLayout.setBackgroundColor(Color.WHITE);
// RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(500,500);
relativeLayout.setLayoutParams(layoutParams);
TextView titleTv = new TextView(context);
titleTv.setText(title);
titleTv.setTextColor(Color.BLUE);
titleTv.setId(titleId);
TextView subTitleTv = new TextView(context);
subTitleTv.setText(subTitle);
subTitleTv.setTextColor(Color.RED);
layoutParams.addRule(RelativeLayout.BELOW,titleId);
RelativeLayout.LayoutParams ivParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
ImageView iconIv = new ImageView(context);
iconIv.setImageResource(icon);
ivParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
ivParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
relativeLayout.addView(titleTv);
relativeLayout.addView(subTitleTv,layoutParams);
relativeLayout.addView(iconIv,ivParams);
return relativeLayout;
}
// public PercentRelativeLayout rectPercentView(Context context, String title,int titleId, String subTitle, int icon, boolean special) throws IOException {
// XmlPullParser parser = Xml.newPullParser();
// try {
// parser.setInput(context.getAssets().open("percent_view.xml"), "UTF-8");// 设置数据源编码
// } catch (XmlPullParserException e) {
// e.printStackTrace();
// }
// XmlPullParser parser = getResources().getXml(R.xml.attrs);
// AttributeSet attrs = Xml.asAttributeSet(parser);
// PercentRelativeLayout relativeLayout = new PercentRelativeLayout(context,attrs);
// relativeLayout.setBackgroundColor(Color.WHITE);
// PercentRelativeLayout.LayoutParams layoutParams = new PercentRelativeLayout.LayoutParams(100,100);
// PercentRelativeLayout.LayoutParams layoutParams = new PercentRelativeLayout.LayoutParams(context,attrs);
// relativeLayout.setLayoutParams(layoutParams);
// TypedArray typeArray = context.obtainStyledAttributes(attrs,
// R.styleable.PercentLayout_Layout);
// layoutParams.setBaseAttributes(typeArray,50,50);
//PercentRelativeLayout relativeLayout = new PercentRelativeLayout(context);
// PercentRelativeLayout.LayoutParams params = (PercentRelativeLayout.LayoutParams) relativeLayout.getLayoutParams();
//// This will currently return null, if it was not constructed from XML.
// PercentLayoutHelper.PercentLayoutInfo info = params.getPercentLayoutInfo();
// info.heightPercent = 0.60f;
// relativeLayout.requestLayout();
// PercentRelativeLayout relativeLayout = new PercentRelativeLayout(context);
// relativeLayout.setBackgroundColor(Color.WHITE);
// PercentRelativeLayout.LayoutParams layoutParams = new PercentRelativeLayout.LayoutParams(500,500);
// relativeLayout.setLayoutParams(layoutParams);
// 百分比
// RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
//// layoutParams.addRule(PercentRelativeLayout);
// TextView titleTv = new TextView(context);
//// titleTv.set
// titleTv.setText(title);
// titleTv.setTextColor(Color.BLUE);
// titleTv.setId(titleId);
// titleTv.setBackgroundColor(Color.YELLOW);
// PercentRelativeLayout.LayoutParams tvPramas = new PercentRelativeLayout.LayoutParams(500,500);
//// (PercentRelativeLayout.LayoutParams) titleTv.getLayoutParams();
////
// layoutParams.la
// PercentLayoutHelper.PercentLayoutInfo info = layoutParams.getPercentLayoutInfo();
// info.widthPercent = 0.80f;
// info.heightPercent = 0.50f;
// titleTv.requestLayout();
//
// TextView subTitleTv = new TextView(context);
// subTitleTv.setText(subTitle);
// subTitleTv.setTextColor(Color.RED);
// PercentRelativeLayout.LayoutParams subTitleTvParams = new PercentRelativeLayout.LayoutParams(PercentRelativeLayout.LayoutParams.WRAP_CONTENT,PercentRelativeLayout.LayoutParams.WRAP_CONTENT);
// subTitleTvParams.addRule(PercentRelativeLayout.BELOW,titleId);
//
//
//
// RelativeLayout.LayoutParams ivParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT,RelativeLayout.LayoutParams.WRAP_CONTENT);
// ImageView iconIv = new ImageView(context);
//
// iconIv.setImageResource(icon);
// ivParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
// ivParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
//
//// relativeLayout.addView(titleTv,tvPramas);
//// relativeLayout.addView(subTitleTv,subTitleTvParams);
//// relativeLayout.addView(iconIv,ivParams);
//// relativeLayout.requestLayout();
// return relativeLayout;
//
// }
}
| true |
46992_72 | package com.heid.games.widget;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.os.Build;
import android.os.SystemClock;
import android.text.Layout;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.ViewTreeObserver;
import com.heid.games.R;
/**
* @author wangchengmeng
* SurfaceView的一般写法
*/
public class LuckSpan extends SurfaceView implements SurfaceHolder.Callback, Runnable {
private static final float CIRCLE_ANGLE = 360;
private static final float HALF_CIRCLE_ANGLE = 180;
//Span的范围
RectF mRectRange;
//圆环的范围
RectF mRectCircleRange;
//绘制盘的画笔
Paint mSpanPaint;
//绘制圆环
// Paint mCirclePaint;
//绘制文本的画笔
Paint mTextPaint;
//转动状态监听
SpanRollListener mSpanRollListener;
//一般都会用到的成员变量
private SurfaceHolder mSurfaceHolder;
private Canvas mCanvas;
//开启线程绘制的线程
private Thread mThread;
//控制线程的开关
private boolean isRunning;
//奖项的名称
private String[] mPrizeName = new String[]{"上家喝光", "倒满", "喝一半", "喝光", "喝一口", "干杯", "下家喝光", "倒满", "喝一半", "喝光", "剩一口", "跳过"};
//奖项的图标
// private int[] mPrizeIcon = new int[]{R.mipmap.danfan, R.mipmap.ipad, R.mipmap.f015, R.mipmap.meizi, R.mipmap.ipad, R.mipmap.iphone, R.mipmap.meizi, R.mipmap.f040};
//与图标对应的Bitmap
// private Bitmap[] mImgIconBitmap;
//盘区域的颜色 这里设置两种颜色交替
private int[] mSpanColor = new int[]{0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF};
//盘的背景
private Bitmap mSpanBackground = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_lucky_bg);
//转盘的直径
private int mRadius;
//设置的padding值，取一个padding值
private int mPadding;
//文字的大小 设置成可配置的属性 TODO
private float mTextSize = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 20, getResources().getDisplayMetrics());
//盘的块数
private int mSpanCount = mPrizeName.length;
//盘滚动的速度 默认为0
private double mSpeed = 0;
//开始转动角度 可能会有多个线程访问 保证线程间的可见性
private volatile float mStartSpanAngle = 0;
//Span的中心
private int mCenter;
//判断是否点击了停止旋转
private boolean isSpanEnd;
//旋转加速度
private int mRotateInt = 100;
private int mTextCenterDistance = 12;
//文字离圆心的距离变量，越大就越远
public LuckSpan(Context context) {
this(context, null);
}
public LuckSpan(Context context, AttributeSet attrs) {
super(context, attrs);
setZOrderOnTop(true);
getHolder().setFormat(PixelFormat.TRANSLUCENT);
setZOrderMediaOverlay(true);
//初始化
mSurfaceHolder = getHolder();
mSurfaceHolder.addCallback(this);
//设置可获得焦点
setFocusable(true);
setFocusableInTouchMode(true);
//这是常亮
setKeepScreenOn(true);
// getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
// @Override
// public void onGlobalLayout() {
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
// getViewTreeObserver().removeOnGlobalLayoutListener(this);
// }
// //背景透明
// }
// });
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//直接控制Span为正方形
int width = Math.min(getMeasuredWidth(), getMeasuredHeight());
mPadding = getPaddingLeft();
//直径
mRadius = width - mPadding * 2;
//设置中心点
mCenter = width / 2;
//设置成正方形
setMeasuredDimension(width, width);
}
@Override
public void surfaceCreated(SurfaceHolder surfaceHolder) {
//初始化绘制Span的画笔
mSpanPaint = new Paint();
mSpanPaint.setAntiAlias(true);
mSpanPaint.setDither(true);
//初始化绘制文本的画笔
mTextPaint = new Paint();
mTextPaint.setTextSize(mTextSize);
mTextPaint.setColor(0Xff6457c2);
mTextPaint.setAntiAlias(true);
mTextPaint.setDither(true);
Typeface font = Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD);
mTextPaint.setTypeface(font);
//绘制圆环的画笔
// mCirclePaint = new Paint();
// mCirclePaint.setAntiAlias(true);
// mCirclePaint.setColor(0xffdfc89c);
//初始化Span的范围
mRectRange = new RectF(mPadding, mPadding, mPadding + mRadius, mPadding + mRadius);
int r = mPadding * 17 / 20;
mRectCircleRange = new RectF(r, r, getMeasuredWidth() - r, getMeasuredWidth() - r);
// mRectCircleRange = new RectF(mPadding * 3 / 2, mPadding * 3 / 2, getMeasuredWidth() - mPadding * 3 / 2, getMeasuredWidth() - mPadding * 3 / 2);
//初始化bitmap
// mImgIconBitmap = new Bitmap[mSpanCount];
//将奖项的icon存储为Bitmap
// for (int i = 0; i < mSpanCount; i++) {
// mImgIconBitmap[i] = BitmapFactory.decodeResource(getResources(), mPrizeIcon[i]);
// }
//surface创建的时候
mThread = new Thread(this);
//创建的时候就开启线程
isRunning = true;
mThread.start();
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {
//变化的时候
}
@Override
public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
//销毁的时候 关闭线程
isRunning = false;
}
@Override
public void run() {
//在子线程中不断的绘制
while (isRunning) {
//保证绘制不低于50毫秒
long start = SystemClock.currentThreadTimeMillis();
draw();
long end = SystemClock.currentThreadTimeMillis();
if ((end - start) < mRotateInt) {
//休眠到50毫秒
SystemClock.sleep(mRotateInt - (end - start));
}
}
}
private void draw() {
try {
mCanvas = mSurfaceHolder.lockCanvas();
if (null != mCanvas) {
//避免执行到这里的时候程序已经退出 surfaceView已经销毁那么获取到canvas为null
//绘制背景
drawBg();
//绘制圆环
// mCanvas.drawCircle(mCenter, mCenter, mRadius / 2 + mPadding / 20, mCirclePaint);
drawSpan();
}
} catch (Exception e) {
//异常可以不必处理
} finally {
//一定要释放canvas避免泄露
mSurfaceHolder.unlockCanvasAndPost(mCanvas);
}
}
//绘制盘块
private void drawSpan() {
float tempAngle = mStartSpanAngle;
float sweepAngle = CIRCLE_ANGLE / mSpanCount;
for (int i = 0; i < mSpanCount; i++) {
Log.d("lucas", "i:" + i + ",tempAngle:" + tempAngle + ",sweepAngle:" + sweepAngle);
mSpanPaint.setColor(mSpanColor[i]);
mCanvas.drawArc(mRectCircleRange, tempAngle, sweepAngle, true, mSpanPaint);
//绘制文字
drawText(tempAngle, sweepAngle, mPrizeName[i], 0);
//绘制奖项Icon
// drawPrizeIcon(tempAngle, mImgIconBitmap[i]);
//改变角度
tempAngle += sweepAngle;
}
//通过修改mSpeed的值让转盘有不同速度的转动
mStartSpanAngle += mSpeed;
if (isSpanEnd) {
mSpeed -= 1;
}
if (mSpeed <= 0) {
//停止旋转了
mSpeed = 0;
isSpanEnd = false;
mSpanRollListener.onSpanRollListener(mSpeed);
}
}
private void drawPrizeIcon(float tempAngle, Bitmap bitmap) {
//图片的大小设置成直径的1/8
int iconWidth = mRadius / 20;
//根据角度计算icon中心点
//角度计算
double angle = (tempAngle + CIRCLE_ANGLE / mSpanCount / 2) * Math.PI / 180;
//计算中心点
int x = (int) (mCenter + mRadius / 4 * Math.cos(angle));
int y = (int) (mCenter + mRadius / 4 * Math.sin(angle));
//定义一个矩形 限制icon位置
RectF rectF = new RectF(x - iconWidth, y - iconWidth, x + iconWidth, y + iconWidth);
mCanvas.drawBitmap(bitmap, null, rectF, null);
}
//绘制文本
private void drawText(float tempAngle, float sweepAngle, String text, int lineNum) {
//绘制有弧度的文字 根据path绘制文字的路径
Path path = new Path();
path.addArc(mRectRange, tempAngle, sweepAngle);
//让文字水平居中 那绘制文字的起点位子就是 弧度的一半 - 文字的一半
float textWidth = mTextPaint.measureText(text);
float hOval = (float) ((mRadius * Math.PI / mSpanCount / 2) - (textWidth / 2));
float vOval = mRadius / mTextCenterDistance + lineNum * 60;//竖直偏移量可以自定义
//如果文字太长，则换行显示
if (text.length() > 2) {
//一行显示两个文字
String str1 = text.substring(0, 2);
String str2 = text.substring(2, text.length());
//重新让文字居中
textWidth = mTextPaint.measureText(str1);
hOval = (float) ((mRadius * Math.PI / mSpanCount / 2) - (textWidth / 2));
mCanvas.drawTextOnPath(str1, path, hOval, vOval, mTextPaint); //第三个四个参数是竖直和水平偏移量
drawText(tempAngle, sweepAngle, str2, ++lineNum);
} else
mCanvas.drawTextOnPath(text, path, hOval, vOval, mTextPaint); //第三个四个参数是竖直和水平偏移量
}
//绘制背景
private void drawBg() {
//背景设置为白色
// mCanvas.drawColor(0x00ffffff);
mCanvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
mCanvas.drawBitmap(mSpanBackground, null, new RectF(mPadding / 2, mPadding / 2, getMeasuredWidth() - mPadding / 2, getMeasuredHeight() - mPadding / 2), mSpanPaint);
}
//网络请求成功后启动转盘
public void luckyStart(int index) {
//根据index控制停留的位置
float angle = CIRCLE_ANGLE / mSpanCount;
//计算指针停留在某个index下的角度范围
float from = HALF_CIRCLE_ANGLE - (index - 1) * angle;
float end = from + angle;
//设置需要停下来的时候转动的距离 保证每次不停留的某个index下的同一个位置
float targetFrom = 3 * CIRCLE_ANGLE + from;
float targetEnd = 3 * CIRCLE_ANGLE + end;//最终停下来的位置在from-end之间，4 * CIRCLE_ANGLE 自定义要多转几圈
//计算要停留下来的时候速度的范围
float vFrom = (float) ((Math.sqrt(1 + 8 * targetFrom) - 1) / 2);
float vEnd = (float) ((Math.sqrt(1 + 8 * targetEnd) - 1) / 2);
//在点击开始转动的时候 传递进来的index值就已经决定停留在那一项上面了
mSpeed = vFrom + Math.random() * (vEnd - vFrom);
isSpanEnd = false;
}
//点击启动转盘
public void defaultStart(int speed) {
mSpeed = speed;
isSpanEnd = false;
}
//停止转盘
public void luckStop() {
//在停止转盘的时候强制吧开始角度赋值为0 因为控制停留指定位置的角度计算是根据开始角度为0计算的
mStartSpanAngle = 0;
isSpanEnd = true;
}
//判断是否还在转动 true --还在转动 反之停止
public boolean isStop() {
return mSpeed == 0;
}
public void setOnSpanRollListener(SpanRollListener spanRollListener) {
this.mSpanRollListener = spanRollListener;
}
public interface SpanRollListener {
void onSpanRollListener(double speed);
}
}
| LucasDevelop/KTVGame | games/src/main/java/com/heid/games/widget/LuckSpan.java | 3,551 | //通过修改mSpeed的值让转盘有不同速度的转动 | line_comment | zh-cn | package com.heid.games.widget;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.os.Build;
import android.os.SystemClock;
import android.text.Layout;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.ViewTreeObserver;
import com.heid.games.R;
/**
* @author wangchengmeng
* SurfaceView的一般写法
*/
public class LuckSpan extends SurfaceView implements SurfaceHolder.Callback, Runnable {
private static final float CIRCLE_ANGLE = 360;
private static final float HALF_CIRCLE_ANGLE = 180;
//Span的范围
RectF mRectRange;
//圆环的范围
RectF mRectCircleRange;
//绘制盘的画笔
Paint mSpanPaint;
//绘制圆环
// Paint mCirclePaint;
//绘制文本的画笔
Paint mTextPaint;
//转动状态监听
SpanRollListener mSpanRollListener;
//一般都会用到的成员变量
private SurfaceHolder mSurfaceHolder;
private Canvas mCanvas;
//开启线程绘制的线程
private Thread mThread;
//控制线程的开关
private boolean isRunning;
//奖项的名称
private String[] mPrizeName = new String[]{"上家喝光", "倒满", "喝一半", "喝光", "喝一口", "干杯", "下家喝光", "倒满", "喝一半", "喝光", "剩一口", "跳过"};
//奖项的图标
// private int[] mPrizeIcon = new int[]{R.mipmap.danfan, R.mipmap.ipad, R.mipmap.f015, R.mipmap.meizi, R.mipmap.ipad, R.mipmap.iphone, R.mipmap.meizi, R.mipmap.f040};
//与图标对应的Bitmap
// private Bitmap[] mImgIconBitmap;
//盘区域的颜色 这里设置两种颜色交替
private int[] mSpanColor = new int[]{0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF, 0XFFf6f4ff, 0XFFFFFFFF};
//盘的背景
private Bitmap mSpanBackground = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_lucky_bg);
//转盘的直径
private int mRadius;
//设置的padding值，取一个padding值
private int mPadding;
//文字的大小 设置成可配置的属性 TODO
private float mTextSize = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, 20, getResources().getDisplayMetrics());
//盘的块数
private int mSpanCount = mPrizeName.length;
//盘滚动的速度 默认为0
private double mSpeed = 0;
//开始转动角度 可能会有多个线程访问 保证线程间的可见性
private volatile float mStartSpanAngle = 0;
//Span的中心
private int mCenter;
//判断是否点击了停止旋转
private boolean isSpanEnd;
//旋转加速度
private int mRotateInt = 100;
private int mTextCenterDistance = 12;
//文字离圆心的距离变量，越大就越远
public LuckSpan(Context context) {
this(context, null);
}
public LuckSpan(Context context, AttributeSet attrs) {
super(context, attrs);
setZOrderOnTop(true);
getHolder().setFormat(PixelFormat.TRANSLUCENT);
setZOrderMediaOverlay(true);
//初始化
mSurfaceHolder = getHolder();
mSurfaceHolder.addCallback(this);
//设置可获得焦点
setFocusable(true);
setFocusableInTouchMode(true);
//这是常亮
setKeepScreenOn(true);
// getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
// @Override
// public void onGlobalLayout() {
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
// getViewTreeObserver().removeOnGlobalLayoutListener(this);
// }
// //背景透明
// }
// });
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//直接控制Span为正方形
int width = Math.min(getMeasuredWidth(), getMeasuredHeight());
mPadding = getPaddingLeft();
//直径
mRadius = width - mPadding * 2;
//设置中心点
mCenter = width / 2;
//设置成正方形
setMeasuredDimension(width, width);
}
@Override
public void surfaceCreated(SurfaceHolder surfaceHolder) {
//初始化绘制Span的画笔
mSpanPaint = new Paint();
mSpanPaint.setAntiAlias(true);
mSpanPaint.setDither(true);
//初始化绘制文本的画笔
mTextPaint = new Paint();
mTextPaint.setTextSize(mTextSize);
mTextPaint.setColor(0Xff6457c2);
mTextPaint.setAntiAlias(true);
mTextPaint.setDither(true);
Typeface font = Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD);
mTextPaint.setTypeface(font);
//绘制圆环的画笔
// mCirclePaint = new Paint();
// mCirclePaint.setAntiAlias(true);
// mCirclePaint.setColor(0xffdfc89c);
//初始化Span的范围
mRectRange = new RectF(mPadding, mPadding, mPadding + mRadius, mPadding + mRadius);
int r = mPadding * 17 / 20;
mRectCircleRange = new RectF(r, r, getMeasuredWidth() - r, getMeasuredWidth() - r);
// mRectCircleRange = new RectF(mPadding * 3 / 2, mPadding * 3 / 2, getMeasuredWidth() - mPadding * 3 / 2, getMeasuredWidth() - mPadding * 3 / 2);
//初始化bitmap
// mImgIconBitmap = new Bitmap[mSpanCount];
//将奖项的icon存储为Bitmap
// for (int i = 0; i < mSpanCount; i++) {
// mImgIconBitmap[i] = BitmapFactory.decodeResource(getResources(), mPrizeIcon[i]);
// }
//surface创建的时候
mThread = new Thread(this);
//创建的时候就开启线程
isRunning = true;
mThread.start();
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {
//变化的时候
}
@Override
public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
//销毁的时候 关闭线程
isRunning = false;
}
@Override
public void run() {
//在子线程中不断的绘制
while (isRunning) {
//保证绘制不低于50毫秒
long start = SystemClock.currentThreadTimeMillis();
draw();
long end = SystemClock.currentThreadTimeMillis();
if ((end - start) < mRotateInt) {
//休眠到50毫秒
SystemClock.sleep(mRotateInt - (end - start));
}
}
}
private void draw() {
try {
mCanvas = mSurfaceHolder.lockCanvas();
if (null != mCanvas) {
//避免执行到这里的时候程序已经退出 surfaceView已经销毁那么获取到canvas为null
//绘制背景
drawBg();
//绘制圆环
// mCanvas.drawCircle(mCenter, mCenter, mRadius / 2 + mPadding / 20, mCirclePaint);
drawSpan();
}
} catch (Exception e) {
//异常可以不必处理
} finally {
//一定要释放canvas避免泄露
mSurfaceHolder.unlockCanvasAndPost(mCanvas);
}
}
//绘制盘块
private void drawSpan() {
float tempAngle = mStartSpanAngle;
float sweepAngle = CIRCLE_ANGLE / mSpanCount;
for (int i = 0; i < mSpanCount; i++) {
Log.d("lucas", "i:" + i + ",tempAngle:" + tempAngle + ",sweepAngle:" + sweepAngle);
mSpanPaint.setColor(mSpanColor[i]);
mCanvas.drawArc(mRectCircleRange, tempAngle, sweepAngle, true, mSpanPaint);
//绘制文字
drawText(tempAngle, sweepAngle, mPrizeName[i], 0);
//绘制奖项Icon
// drawPrizeIcon(tempAngle, mImgIconBitmap[i]);
//改变角度
tempAngle += sweepAngle;
}
//通过 <SUF>
mStartSpanAngle += mSpeed;
if (isSpanEnd) {
mSpeed -= 1;
}
if (mSpeed <= 0) {
//停止旋转了
mSpeed = 0;
isSpanEnd = false;
mSpanRollListener.onSpanRollListener(mSpeed);
}
}
private void drawPrizeIcon(float tempAngle, Bitmap bitmap) {
//图片的大小设置成直径的1/8
int iconWidth = mRadius / 20;
//根据角度计算icon中心点
//角度计算
double angle = (tempAngle + CIRCLE_ANGLE / mSpanCount / 2) * Math.PI / 180;
//计算中心点
int x = (int) (mCenter + mRadius / 4 * Math.cos(angle));
int y = (int) (mCenter + mRadius / 4 * Math.sin(angle));
//定义一个矩形 限制icon位置
RectF rectF = new RectF(x - iconWidth, y - iconWidth, x + iconWidth, y + iconWidth);
mCanvas.drawBitmap(bitmap, null, rectF, null);
}
//绘制文本
private void drawText(float tempAngle, float sweepAngle, String text, int lineNum) {
//绘制有弧度的文字 根据path绘制文字的路径
Path path = new Path();
path.addArc(mRectRange, tempAngle, sweepAngle);
//让文字水平居中 那绘制文字的起点位子就是 弧度的一半 - 文字的一半
float textWidth = mTextPaint.measureText(text);
float hOval = (float) ((mRadius * Math.PI / mSpanCount / 2) - (textWidth / 2));
float vOval = mRadius / mTextCenterDistance + lineNum * 60;//竖直偏移量可以自定义
//如果文字太长，则换行显示
if (text.length() > 2) {
//一行显示两个文字
String str1 = text.substring(0, 2);
String str2 = text.substring(2, text.length());
//重新让文字居中
textWidth = mTextPaint.measureText(str1);
hOval = (float) ((mRadius * Math.PI / mSpanCount / 2) - (textWidth / 2));
mCanvas.drawTextOnPath(str1, path, hOval, vOval, mTextPaint); //第三个四个参数是竖直和水平偏移量
drawText(tempAngle, sweepAngle, str2, ++lineNum);
} else
mCanvas.drawTextOnPath(text, path, hOval, vOval, mTextPaint); //第三个四个参数是竖直和水平偏移量
}
//绘制背景
private void drawBg() {
//背景设置为白色
// mCanvas.drawColor(0x00ffffff);
mCanvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
mCanvas.drawBitmap(mSpanBackground, null, new RectF(mPadding / 2, mPadding / 2, getMeasuredWidth() - mPadding / 2, getMeasuredHeight() - mPadding / 2), mSpanPaint);
}
//网络请求成功后启动转盘
public void luckyStart(int index) {
//根据index控制停留的位置
float angle = CIRCLE_ANGLE / mSpanCount;
//计算指针停留在某个index下的角度范围
float from = HALF_CIRCLE_ANGLE - (index - 1) * angle;
float end = from + angle;
//设置需要停下来的时候转动的距离 保证每次不停留的某个index下的同一个位置
float targetFrom = 3 * CIRCLE_ANGLE + from;
float targetEnd = 3 * CIRCLE_ANGLE + end;//最终停下来的位置在from-end之间，4 * CIRCLE_ANGLE 自定义要多转几圈
//计算要停留下来的时候速度的范围
float vFrom = (float) ((Math.sqrt(1 + 8 * targetFrom) - 1) / 2);
float vEnd = (float) ((Math.sqrt(1 + 8 * targetEnd) - 1) / 2);
//在点击开始转动的时候 传递进来的index值就已经决定停留在那一项上面了
mSpeed = vFrom + Math.random() * (vEnd - vFrom);
isSpanEnd = false;
}
//点击启动转盘
public void defaultStart(int speed) {
mSpeed = speed;
isSpanEnd = false;
}
//停止转盘
public void luckStop() {
//在停止转盘的时候强制吧开始角度赋值为0 因为控制停留指定位置的角度计算是根据开始角度为0计算的
mStartSpanAngle = 0;
isSpanEnd = true;
}
//判断是否还在转动 true --还在转动 反之停止
public boolean isStop() {
return mSpeed == 0;
}
public void setOnSpanRollListener(SpanRollListener spanRollListener) {
this.mSpanRollListener = spanRollListener;
}
public interface SpanRollListener {
void onSpanRollListener(double speed);
}
}
| true |
31937_1 | package work;
/**
* 练习
*/
public class Person1 {
public String name;
public int age;
public int sex;
/**
* 学习
*/
public void study() {
System.out.println("studying");
}
/**
* 输出年龄
*/
public void showAge() {
System.out.println(age);
}
/**
* 年龄加2
* @return
*/
public int addAge(int i) {
age +=i;
return age;
}
}
| LucasGini/LearningRecord | Java/work/Person1.java | 128 | /**
* 学习
*/ | block_comment | zh-cn | package work;
/**
* 练习
*/
public class Person1 {
public String name;
public int age;
public int sex;
/**
* 学习
<SUF>*/
public void study() {
System.out.println("studying");
}
/**
* 输出年龄
*/
public void showAge() {
System.out.println(age);
}
/**
* 年龄加2
* @return
*/
public int addAge(int i) {
age +=i;
return age;
}
}
| false |
38583_13 | package com.lucidastar.hodgepodge.ui.activity.otherfeature.view;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Bundle;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import com.lucidastar.hodgepodge.R;
import com.lucidastar.hodgepodge.ui.activity.otherfeature.view.cusview.RadarView;
import com.mine.lucidastarutils.utils.ScreenUtils;
public class StudyViewActivity extends AppCompatActivity {
private Toolbar mToolbar;
RadarView mRadarView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_study_view);
mRadarView = findViewById(R.id.rdv);
mToolbar = (Toolbar) findViewById(R.id.toolbar);
//设置title
mToolbar.setTitle("view的一些知识点");
//设置副标题
// mToolbar.setSubtitle("subTitle");
//设置logo
// mToolbar.setLogo(R.mipmap.ic_launcher);
mToolbar.setSubtitleTextColor(getResources().getColor(R.color.white));
//这些简单的属性也可以在xml中进行设置
setSupportActionBar(mToolbar);
mToolbar.setNavigationIcon(R.drawable.ic_arrow_back_black_24dp);//设置返回按钮
mToolbar.setTitleTextColor(getResources().getColor(R.color.white));
mToolbar.setNavigationOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
finish();
}
});
initRadarView();
}
private void initRadarView(){
mRadarView.setCount(5);
mRadarView.setLayerCount(4);
mRadarView.setEnabledShade(true);//绘制渐变环
mRadarView.setEnabledRegionShader(true);//允许区域颜色渐变
mRadarView.setEnabledShowPoint(true);//显示圆点
mRadarView.setStartColor(Color.parseColor("#9bc6f5"));//开启渐变色时，圆心处的颜色
mRadarView.setEndColor(Color.parseColor("#e8f0fa"));//开启渐变色时，外圈处的颜色
mRadarView.setLineColor(Color.parseColor("#ff0000"));//圆心与各个顶点连线的颜色
//圆点空心填充白色 圆点与圆点线的颜色
Paint mPaint = new Paint();
mPaint.setStyle(Paint.Style.FILL);
mPaint.setAntiAlias(true);
mPaint.setStrokeWidth(ScreenUtils.px2dp(this,24));
mPaint.setColor(Color.parseColor("#ffffff"));
mRadarView.setPointColor(mPaint);//圆点颜色
mRadarView.setEnabledBorder(true);
mRadarView.setBorderColor(Color.parseColor("#2269BB"));//圆点与圆点之间的连线
mRadarView.setTitles(new String[]{"意识","实战","知识","专业","经验"});
mRadarView.setCobwebColor(Color.parseColor("#00000000"));
mRadarView.setRadiusLineWidth(ScreenUtils.px2dp(this,24));
mRadarView.setDataSize(60);
mRadarView.setValues(new String[]{"12.5","26","58","45","15"});
// mRadarView.setDrawables(new int[]{12,26,58,45,15});
double percents[] = new double[]{0.8, 0.8, 0.9, 1, 0.6};
mRadarView.setPercents(percents);
mRadarView.setEnabledText(true);
mRadarView.setEnabledRadius(true);
mRadarView.setPointRadius(12);
mRadarView.setDataColor(Color.parseColor("#7498FF"));
}
}
| Lucidastar/hodgepodgeForAndroid | app/src/main/java/com/lucidastar/hodgepodge/ui/activity/otherfeature/view/StudyViewActivity.java | 976 | //圆点空心填充白色 圆点与圆点线的颜色 | line_comment | zh-cn | package com.lucidastar.hodgepodge.ui.activity.otherfeature.view;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Bundle;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import com.lucidastar.hodgepodge.R;
import com.lucidastar.hodgepodge.ui.activity.otherfeature.view.cusview.RadarView;
import com.mine.lucidastarutils.utils.ScreenUtils;
public class StudyViewActivity extends AppCompatActivity {
private Toolbar mToolbar;
RadarView mRadarView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_study_view);
mRadarView = findViewById(R.id.rdv);
mToolbar = (Toolbar) findViewById(R.id.toolbar);
//设置title
mToolbar.setTitle("view的一些知识点");
//设置副标题
// mToolbar.setSubtitle("subTitle");
//设置logo
// mToolbar.setLogo(R.mipmap.ic_launcher);
mToolbar.setSubtitleTextColor(getResources().getColor(R.color.white));
//这些简单的属性也可以在xml中进行设置
setSupportActionBar(mToolbar);
mToolbar.setNavigationIcon(R.drawable.ic_arrow_back_black_24dp);//设置返回按钮
mToolbar.setTitleTextColor(getResources().getColor(R.color.white));
mToolbar.setNavigationOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
finish();
}
});
initRadarView();
}
private void initRadarView(){
mRadarView.setCount(5);
mRadarView.setLayerCount(4);
mRadarView.setEnabledShade(true);//绘制渐变环
mRadarView.setEnabledRegionShader(true);//允许区域颜色渐变
mRadarView.setEnabledShowPoint(true);//显示圆点
mRadarView.setStartColor(Color.parseColor("#9bc6f5"));//开启渐变色时，圆心处的颜色
mRadarView.setEndColor(Color.parseColor("#e8f0fa"));//开启渐变色时，外圈处的颜色
mRadarView.setLineColor(Color.parseColor("#ff0000"));//圆心与各个顶点连线的颜色
//圆点 <SUF>
Paint mPaint = new Paint();
mPaint.setStyle(Paint.Style.FILL);
mPaint.setAntiAlias(true);
mPaint.setStrokeWidth(ScreenUtils.px2dp(this,24));
mPaint.setColor(Color.parseColor("#ffffff"));
mRadarView.setPointColor(mPaint);//圆点颜色
mRadarView.setEnabledBorder(true);
mRadarView.setBorderColor(Color.parseColor("#2269BB"));//圆点与圆点之间的连线
mRadarView.setTitles(new String[]{"意识","实战","知识","专业","经验"});
mRadarView.setCobwebColor(Color.parseColor("#00000000"));
mRadarView.setRadiusLineWidth(ScreenUtils.px2dp(this,24));
mRadarView.setDataSize(60);
mRadarView.setValues(new String[]{"12.5","26","58","45","15"});
// mRadarView.setDrawables(new int[]{12,26,58,45,15});
double percents[] = new double[]{0.8, 0.8, 0.9, 1, 0.6};
mRadarView.setPercents(percents);
mRadarView.setEnabledText(true);
mRadarView.setEnabledRadius(true);
mRadarView.setPointRadius(12);
mRadarView.setDataColor(Color.parseColor("#7498FF"));
}
}
| true |
49298_1 | ## 大萨达
## 第n个数字
在无限的整数序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...中找到第 n 个数字。
注意:
n 是正数且在32位整数范围内 ( n < 2^31)。
示例 1:
输入:
3
输出:
3
示例 2:
输入:
11
输出:
0
说明:
第11个数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是0，它是10的一部分。
//好奇怪啊，我的int居然撑不到10^9，不是可以到2^31吗，只能强行用long
class Solution {
public int findNthDigit(long n) {
int i =1;
long N =9;
while(n-N*i>0){
n-= N*i;
i++;
N *= 10;
}
//i是输出所属数字的位数，indice是输出在该数字中的位数，从第一个i位数：ini 数起第n个字符是输出
long ini = puissDix(i-1);
int indice = (int)n%i;
//输出为某数字末位
if(indice == 0){
long nombre = ini + n/i -1;
return (int)nombre % 10;
}
//输出为某数字首位
else if(indice == 1){
long nombre = ini + n/i;
nombre /= puissDix(i-indice);
return (int)nombre;
}
//输出为某数字中间位
else{
long nombre = ini + n/i;
System.out.println(nombre);
nombre %= puissDix(i-indice+1);
nombre /= puissDix(i-indice);
return (int)nombre;
}
}
public long puissDix(int y){
long res = 1;
for(int k =0; k<y; k++){
res *= 10;
}
return res;
}
}
| LucienJi/Test | LeetCode/400.java | 552 | //i是输出所属数字的位数，indice是输出在该数字中的位数，从第一个i位数：ini 数起第n个字符是输出 | line_comment | zh-cn | ## 大萨达
## 第n个数字
在无限的整数序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...中找到第 n 个数字。
注意:
n 是正数且在32位整数范围内 ( n < 2^31)。
示例 1:
输入:
3
输出:
3
示例 2:
输入:
11
输出:
0
说明:
第11个数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是0，它是10的一部分。
//好奇怪啊，我的int居然撑不到10^9，不是可以到2^31吗，只能强行用long
class Solution {
public int findNthDigit(long n) {
int i =1;
long N =9;
while(n-N*i>0){
n-= N*i;
i++;
N *= 10;
}
//i是 <SUF>
long ini = puissDix(i-1);
int indice = (int)n%i;
//输出为某数字末位
if(indice == 0){
long nombre = ini + n/i -1;
return (int)nombre % 10;
}
//输出为某数字首位
else if(indice == 1){
long nombre = ini + n/i;
nombre /= puissDix(i-indice);
return (int)nombre;
}
//输出为某数字中间位
else{
long nombre = ini + n/i;
System.out.println(nombre);
nombre %= puissDix(i-indice+1);
nombre /= puissDix(i-indice);
return (int)nombre;
}
}
public long puissDix(int y){
long res = 1;
for(int k =0; k<y; k++){
res *= 10;
}
return res;
}
}
| true |
23024_7 | package com.lyang.demo.fanxing;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Created by yanglu on 2016/10/18.
*/
public class TestGenericsBasic {
public static <T extends Fruit> void print(T t){
System.out.println(t.getClass());
System.out.println(Class.class);
t.eat();
}
public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static <T extends Fruit> T createInstance2(Class<T> clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
//测试泛型继承自Fruit
print(new Apple());
print(new Banana());
//测试通过泛型创建类的实例，不用强制转换
Fruit fruit= createInstance(Fruit.class);
People people= createInstance(People.class);
//测试指定上限通配符
//编译不通过 , 因为People类没有继承自Fruit
//People people2= createInstance2(People.class);
Apple apple3= createInstance2(Apple.class);
/*使用了泛型，再也不用强转对象了*/
Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();
/*没有使用泛型，仍需强转成Apple类*/
Box box2 = new Box();
box2.set(new Apple());
Apple apple2 = (Apple) box2.get();
}
}
| LucienYang/FanxingDemo | src/com/lyang/demo/fanxing/TestGenericsBasic.java | 405 | /*没有使用泛型，仍需强转成Apple类*/ | block_comment | zh-cn | package com.lyang.demo.fanxing;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Created by yanglu on 2016/10/18.
*/
public class TestGenericsBasic {
public static <T extends Fruit> void print(T t){
System.out.println(t.getClass());
System.out.println(Class.class);
t.eat();
}
public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static <T extends Fruit> T createInstance2(Class<T> clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
//测试泛型继承自Fruit
print(new Apple());
print(new Banana());
//测试通过泛型创建类的实例，不用强制转换
Fruit fruit= createInstance(Fruit.class);
People people= createInstance(People.class);
//测试指定上限通配符
//编译不通过 , 因为People类没有继承自Fruit
//People people2= createInstance2(People.class);
Apple apple3= createInstance2(Apple.class);
/*使用了泛型，再也不用强转对象了*/
Box<Apple> box = new Box<Apple>();
box.set(new Apple());
Apple apple = box.get();
/*没有使 <SUF>*/
Box box2 = new Box();
box2.set(new Apple());
Apple apple2 = (Apple) box2.get();
}
}
| true |
23060_3 | /**
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param preOrder int整型vector
* @param inOrder int整型vector
* @return TreeNode类vector
*/
vector<TreeNode*> func(vector<int>& preOrder,int pl,int pr,vector<int>& inOrder,int il,int ir)
{//工作函数，参数分别为前序遍历数组及前序遍历数组的左右边界，中序遍历数组及其左右边界。
//本质是处理返回参数问题，就是传子树的前序遍历和中序遍历
vector<TreeNode*> res;
if(pl>pr)//如果左边界大于右边界，则返回空
{
res.push_back(nullptr);//此处情况对应，以叶子节点为root，可能的左右子树的构建，因为叶子节点左右都为空，所以只返回一个只有nullptr的数组。
return res;
}
for(int i = il;i<=ir;++i)//查找中序遍历数组
{
if(inOrder[i] == preOrder[pl])//查找到根
{
vector<TreeNode*> left = func(preOrder,pl+1,pl+i-il,inOrder,il,i-1);//递归查找左子树
vector<TreeNode*> right = func(preOrder,pl+i-il+1,pr,inOrder,i+1,ir);//递归查找右子树
for(auto lc:left)
{
for(auto rc:right)//遍历左孩子vector和右孩子vector
{
TreeNode* root_node = new TreeNode(preOrder[pl]);//创建根节点
root_node->left = lc;//组装根节点可能的左孩子和右孩子
root_node->right = rc;
res.push_back(root_node);//并将该根节点push进返回结果vector中
}
}
}
}
return res;//返回结果，该结果的含义应该是“以root为根的，所有可能的树的构建，的数组”
}
vector<TreeNode*> getBinaryTrees(vector<int>& preOrder, vector<int>& inOrder) {
// write code here
vector<TreeNode*> ans;
ans = func(preOrder,0,preOrder.size()-1,inOrder,0,inOrder.size()-1);
return ans;
}
}; | LuckRain7/MyBlog | exam/1.java | 629 | //本质是处理返回参数问题，就是传子树的前序遍历和中序遍历 | line_comment | zh-cn | /**
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* };
*/
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param preOrder int整型vector
* @param inOrder int整型vector
* @return TreeNode类vector
*/
vector<TreeNode*> func(vector<int>& preOrder,int pl,int pr,vector<int>& inOrder,int il,int ir)
{//工作函数，参数分别为前序遍历数组及前序遍历数组的左右边界，中序遍历数组及其左右边界。
//本质 <SUF>
vector<TreeNode*> res;
if(pl>pr)//如果左边界大于右边界，则返回空
{
res.push_back(nullptr);//此处情况对应，以叶子节点为root，可能的左右子树的构建，因为叶子节点左右都为空，所以只返回一个只有nullptr的数组。
return res;
}
for(int i = il;i<=ir;++i)//查找中序遍历数组
{
if(inOrder[i] == preOrder[pl])//查找到根
{
vector<TreeNode*> left = func(preOrder,pl+1,pl+i-il,inOrder,il,i-1);//递归查找左子树
vector<TreeNode*> right = func(preOrder,pl+i-il+1,pr,inOrder,i+1,ir);//递归查找右子树
for(auto lc:left)
{
for(auto rc:right)//遍历左孩子vector和右孩子vector
{
TreeNode* root_node = new TreeNode(preOrder[pl]);//创建根节点
root_node->left = lc;//组装根节点可能的左孩子和右孩子
root_node->right = rc;
res.push_back(root_node);//并将该根节点push进返回结果vector中
}
}
}
}
return res;//返回结果，该结果的含义应该是“以root为根的，所有可能的树的构建，的数组”
}
vector<TreeNode*> getBinaryTrees(vector<int>& preOrder, vector<int>& inOrder) {
// write code here
vector<TreeNode*> ans;
ans = func(preOrder,0,preOrder.size()-1,inOrder,0,inOrder.size()-1);
return ans;
}
}; | true |
62174_2 | /*
* Copyright (C) 2014 Peter Cai
*
* This file is part of BlackLight
*
* BlackLight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* BlackLight is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with BlackLight. If not, see <http://www.gnu.org/licenses/>.
*/
package com.luck.keyboard.emoji;
import android.text.TextUtils;
import java.util.HashMap;
import java.util.Map;
/*
This class maps emoticon strings to asset imgs
Thanks sina for those emoticons
*/
public class Emoticons {
public static Map<String, String> emojiMap;
static {
emojiMap = new HashMap<String, String>();
//默认的表情
emojiMap.put("[爱你]", "d_aini");
emojiMap.put("[奥特曼]", "d_aoteman");
emojiMap.put("[拜拜]", "d_baibai");
emojiMap.put("[悲伤]", "d_beishang");
emojiMap.put("[鄙视]", "d_bishi");
emojiMap.put("[闭嘴]", "d_bizui");
emojiMap.put("[馋嘴]", "d_chanzui");
emojiMap.put("[吃惊]", "d_chijing");
emojiMap.put("[哈欠]", "d_dahaqi");
emojiMap.put("[打脸]", "d_dalian");
emojiMap.put("[顶]", "d_ding");
emojiMap.put("[doge]", "d_doge");
emojiMap.put("[肥皂]", "d_feizao");
emojiMap.put("[感冒]", "d_ganmao");
emojiMap.put("[鼓掌]", "d_guzhang");
emojiMap.put("[哈哈]", "d_haha");
emojiMap.put("[害羞]", "d_haixiu");
emojiMap.put("[汗]", "d_han");
emojiMap.put("[呵呵]", "d_hehe");
emojiMap.put("[微笑]", "d_hehe");
emojiMap.put("[黑线]", "d_heixian");
emojiMap.put("[哼]", "d_heng");
emojiMap.put("[花心]", "d_huaxin");
emojiMap.put("[挤眼]", "d_jiyan");
emojiMap.put("[可爱]", "d_keai");
emojiMap.put("[可怜]", "d_kelian");
emojiMap.put("[酷]", "d_ku");
emojiMap.put("[困]", "d_kun");
emojiMap.put("[懒得理你]", "d_landelini");
emojiMap.put("[泪]", "d_lei");
emojiMap.put("[马到成功]", "d_madaochenggong");
emojiMap.put("[喵喵]", "d_miao");
emojiMap.put("[男孩儿]", "d_nanhaier");
emojiMap.put("[怒]", "d_nu");
emojiMap.put("[愤怒]", "d_nu");
emojiMap.put("[怒骂]", "d_numa");
emojiMap.put("[钱]", "d_qian");
emojiMap.put("[亲亲]", "d_qinqin");
emojiMap.put("[傻眼]", "d_shayan");
emojiMap.put("[生病]", "d_shengbing");
emojiMap.put("[神兽]", "d_shenshou");
emojiMap.put("[草泥马]", "d_shenshou");
emojiMap.put("[失望]", "d_shiwang");
emojiMap.put("[衰]", "d_shuai");
emojiMap.put("[睡觉]", "d_shuijiao");
emojiMap.put("[睡]", "d_shuijiao");
emojiMap.put("[思考]", "d_sikao");
emojiMap.put("[太开心]", "d_taikaixin");
emojiMap.put("[抱抱]", "d_taikaixin");
emojiMap.put("[偷笑]", "d_touxiao");
emojiMap.put("[吐]", "d_tu");
emojiMap.put("[兔子]", "d_tuzi");
emojiMap.put("[挖鼻屎]", "d_wabishi");
emojiMap.put("[挖鼻]", "d_wabishi");
emojiMap.put("[委屈]", "d_weiqu");
emojiMap.put("[笑cry]", "d_xiaoku");
emojiMap.put("[熊猫]", "d_xiongmao");
emojiMap.put("[嘻嘻]", "d_xixi");
emojiMap.put("[嘘]", "d_xu");
emojiMap.put("[阴险]", "d_yinxian");
emojiMap.put("[疑问]", "d_yiwen");
emojiMap.put("[右哼哼]", "d_youhengheng");
emojiMap.put("[晕]", "d_yun");
emojiMap.put("[抓狂]", "d_zhuakuang");
emojiMap.put("[猪头]", "d_zhutou");
emojiMap.put("[最右]", "d_zuiyou");
emojiMap.put("[左哼哼]", "d_zuohengheng");
emojiMap.put("[给力]", "f_geili");
//浪小花表情
emojiMap.put("[悲催]", "lxh_beicui");
emojiMap.put("[被电]", "lxh_beidian");
emojiMap.put("[崩溃]", "lxh_bengkui");
emojiMap.put("[别烦我]", "lxh_biefanwo");
emojiMap.put("[不好意思]", "lxh_buhaoyisi");
emojiMap.put("[不想上班]", "lxh_buxiangshangban");
emojiMap.put("[得意地笑]", "lxh_deyidexiao");
emojiMap.put("[给劲]", "lxh_feijin");
emojiMap.put("[好爱哦]", "lxh_haoaio");
emojiMap.put("[好棒]", "lxh_haobang");
emojiMap.put("[好囧]", "lxh_haojiong");
emojiMap.put("[好喜欢]", "lxh_haoxihuan");
emojiMap.put("[hold住]", "lxh_holdzhu");
emojiMap.put("[杰克逊]", "lxh_jiekexun");
emojiMap.put("[纠结]", "lxh_jiujie");
emojiMap.put("[巨汗]", "lxh_juhan");
emojiMap.put("[抠鼻屎]", "lxh_koubishi");
emojiMap.put("[困死了]", "lxh_kunsile");
emojiMap.put("[雷锋]", "lxh_leifeng");
emojiMap.put("[泪流满面]", "lxh_leiliumanmian");
emojiMap.put("[玫瑰]", "lxh_meigui");
emojiMap.put("[噢耶]", "lxh_oye");
emojiMap.put("[霹雳]", "lxh_pili");
emojiMap.put("[瞧瞧]", "lxh_qiaoqiao");
emojiMap.put("[丘比特]", "lxh_qiubite");
emojiMap.put("[求关注]", "lxh_qiuguanzhu");
emojiMap.put("[群体围观]", "lxh_quntiweiguan");
emojiMap.put("[甩甩手]", "lxh_shuaishuaishou");
emojiMap.put("[偷乐]", "lxh_toule");
emojiMap.put("[推荐]", "lxh_tuijian");
emojiMap.put("[互相膜拜]", "lxh_xianghumobai");
emojiMap.put("[想一想]", "lxh_xiangyixiang");
emojiMap.put("[笑哈哈]", "lxh_xiaohaha");
emojiMap.put("[羞嗒嗒]", "lxh_xiudada");
emojiMap.put("[许愿]", "lxh_xuyuan");
emojiMap.put("[有鸭梨]", "lxh_youyali");
emojiMap.put("[震惊]", "lxh_zhenjing");
emojiMap.put("[转发]", "lxh_zhuanfa");
//其他
emojiMap.put("[蛋糕]", "o_dangao");
emojiMap.put("[飞机]", "o_feiji");
emojiMap.put("[干杯]", "o_ganbei");
emojiMap.put("[话筒]", "o_huatong");
emojiMap.put("[蜡烛]", "o_lazhu");
emojiMap.put("[礼物]", "o_liwu");
emojiMap.put("[围观]", "o_weiguan");
emojiMap.put("[咖啡]", "o_kafei");
emojiMap.put("[足球]", "o_zuqiu");
emojiMap.put("[ok]", "h_ok");
emojiMap.put("[躁狂症]", "lxh_zaokuangzheng");
emojiMap.put("[赞]", "h_zan");
emojiMap.put("[心]", "l_xin");
emojiMap.put("[伤心]", "l_shangxin");
emojiMap.put("[月亮]", "w_yueliang");
emojiMap.put("[鲜花]", "w_xianhua");
emojiMap.put("[太阳]", "w_taiyang");
emojiMap.put("[浮云]", "w_fuyun");
emojiMap.put("[神马]", "f_shenma");
emojiMap.put("[微风]", "w_weifeng");
emojiMap.put("[下雨]", "w_xiayu");
emojiMap.put("[色]", "d_huaxin");
emojiMap.put("[沙尘暴]", "w_shachenbao");
emojiMap.put("[落叶]", "w_luoye");
emojiMap.put("[雪人]", "w_xueren");
emojiMap.put("[good]", "h_good");
emojiMap.put("[哆啦A梦吃惊]", "dorahaose_mobile");
emojiMap.put("[哆啦A梦微笑]", "jqmweixiao_mobile");
emojiMap.put("[哆啦A梦花心]", "dorahaose_mobile");
emojiMap.put("[炸鸡啤酒]", "d_zhajipijiu");
emojiMap.put("[炸鸡和啤酒]", "d_zhajipijiu");
emojiMap.put("[囧]", "jiong");
emojiMap.put("[NO]", "buyao");
emojiMap.put("[来]", "guolai");
emojiMap.put("[互粉]", "f_hufen");
emojiMap.put("[握手]", "h_woshou");
emojiMap.put("[haha]", "h_haha");
emojiMap.put("[织]", "zhi");
emojiMap.put("[萌]", "meng");
emojiMap.put("[钟]", "o_zhong");
emojiMap.put("[喜]", "xi");
emojiMap.put("[绿丝带]", "o_lvsidai");
emojiMap.put("[围脖]", "weibo");
emojiMap.put("[音乐]", "o_yinyue");
emojiMap.put("[照相机]", "o_zhaoxiangji");
emojiMap.put("[耶]", "h_ye");
emojiMap.put("[发红包]", "o_fahongbao1x");
emojiMap.put("[拍照]", "lxhpz_paizhao");
emojiMap.put("[白眼]", "landeln_baiyan");
emojiMap.put("[囧]", "f_jiong");
emojiMap.put("[萌]", "f_meng");
emojiMap.put("[威武]", "f_v5");
emojiMap.put("[喜]", "f_xi");
emojiMap.put("[带着微博去旅行]", "d_travel1x");
emojiMap.put("[不要]", "h_buyao");
emojiMap.put("[织]", "f_zhi");
emojiMap.put("[good]", "h_good");
emojiMap.put("[来]", "h_lai");
emojiMap.put("[弱]", "h_ruo");
emojiMap.put("[围脖]", "o_weibo");
emojiMap.put("[作揖]", "h_zuoyi");
emojiMap.put("[拳头]", "h_quantou");
emojiMap.put("[X教授]", "xman_jiaoshou");
emojiMap.put("[天启]", "xman_tianqi");
emojiMap.put("[抢到啦]", "hb_qiangdao_org");
}
/**
* @param emojiText like [挖鼻]
* @return 返回图片的名字
*/
public static String getImgName(String emojiText) {
String ImgName = emojiMap.get(emojiText);
if (!TextUtils.isEmpty(ImgName)) {
return ImgName;
} else {
return null;
}
}
}
| LuckSiege/Keyboard | app/src/main/java/com/luck/keyboard/emoji/Emoticons.java | 3,364 | //默认的表情 | line_comment | zh-cn | /*
* Copyright (C) 2014 Peter Cai
*
* This file is part of BlackLight
*
* BlackLight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* BlackLight is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with BlackLight. If not, see <http://www.gnu.org/licenses/>.
*/
package com.luck.keyboard.emoji;
import android.text.TextUtils;
import java.util.HashMap;
import java.util.Map;
/*
This class maps emoticon strings to asset imgs
Thanks sina for those emoticons
*/
public class Emoticons {
public static Map<String, String> emojiMap;
static {
emojiMap = new HashMap<String, String>();
//默认 <SUF>
emojiMap.put("[爱你]", "d_aini");
emojiMap.put("[奥特曼]", "d_aoteman");
emojiMap.put("[拜拜]", "d_baibai");
emojiMap.put("[悲伤]", "d_beishang");
emojiMap.put("[鄙视]", "d_bishi");
emojiMap.put("[闭嘴]", "d_bizui");
emojiMap.put("[馋嘴]", "d_chanzui");
emojiMap.put("[吃惊]", "d_chijing");
emojiMap.put("[哈欠]", "d_dahaqi");
emojiMap.put("[打脸]", "d_dalian");
emojiMap.put("[顶]", "d_ding");
emojiMap.put("[doge]", "d_doge");
emojiMap.put("[肥皂]", "d_feizao");
emojiMap.put("[感冒]", "d_ganmao");
emojiMap.put("[鼓掌]", "d_guzhang");
emojiMap.put("[哈哈]", "d_haha");
emojiMap.put("[害羞]", "d_haixiu");
emojiMap.put("[汗]", "d_han");
emojiMap.put("[呵呵]", "d_hehe");
emojiMap.put("[微笑]", "d_hehe");
emojiMap.put("[黑线]", "d_heixian");
emojiMap.put("[哼]", "d_heng");
emojiMap.put("[花心]", "d_huaxin");
emojiMap.put("[挤眼]", "d_jiyan");
emojiMap.put("[可爱]", "d_keai");
emojiMap.put("[可怜]", "d_kelian");
emojiMap.put("[酷]", "d_ku");
emojiMap.put("[困]", "d_kun");
emojiMap.put("[懒得理你]", "d_landelini");
emojiMap.put("[泪]", "d_lei");
emojiMap.put("[马到成功]", "d_madaochenggong");
emojiMap.put("[喵喵]", "d_miao");
emojiMap.put("[男孩儿]", "d_nanhaier");
emojiMap.put("[怒]", "d_nu");
emojiMap.put("[愤怒]", "d_nu");
emojiMap.put("[怒骂]", "d_numa");
emojiMap.put("[钱]", "d_qian");
emojiMap.put("[亲亲]", "d_qinqin");
emojiMap.put("[傻眼]", "d_shayan");
emojiMap.put("[生病]", "d_shengbing");
emojiMap.put("[神兽]", "d_shenshou");
emojiMap.put("[草泥马]", "d_shenshou");
emojiMap.put("[失望]", "d_shiwang");
emojiMap.put("[衰]", "d_shuai");
emojiMap.put("[睡觉]", "d_shuijiao");
emojiMap.put("[睡]", "d_shuijiao");
emojiMap.put("[思考]", "d_sikao");
emojiMap.put("[太开心]", "d_taikaixin");
emojiMap.put("[抱抱]", "d_taikaixin");
emojiMap.put("[偷笑]", "d_touxiao");
emojiMap.put("[吐]", "d_tu");
emojiMap.put("[兔子]", "d_tuzi");
emojiMap.put("[挖鼻屎]", "d_wabishi");
emojiMap.put("[挖鼻]", "d_wabishi");
emojiMap.put("[委屈]", "d_weiqu");
emojiMap.put("[笑cry]", "d_xiaoku");
emojiMap.put("[熊猫]", "d_xiongmao");
emojiMap.put("[嘻嘻]", "d_xixi");
emojiMap.put("[嘘]", "d_xu");
emojiMap.put("[阴险]", "d_yinxian");
emojiMap.put("[疑问]", "d_yiwen");
emojiMap.put("[右哼哼]", "d_youhengheng");
emojiMap.put("[晕]", "d_yun");
emojiMap.put("[抓狂]", "d_zhuakuang");
emojiMap.put("[猪头]", "d_zhutou");
emojiMap.put("[最右]", "d_zuiyou");
emojiMap.put("[左哼哼]", "d_zuohengheng");
emojiMap.put("[给力]", "f_geili");
//浪小花表情
emojiMap.put("[悲催]", "lxh_beicui");
emojiMap.put("[被电]", "lxh_beidian");
emojiMap.put("[崩溃]", "lxh_bengkui");
emojiMap.put("[别烦我]", "lxh_biefanwo");
emojiMap.put("[不好意思]", "lxh_buhaoyisi");
emojiMap.put("[不想上班]", "lxh_buxiangshangban");
emojiMap.put("[得意地笑]", "lxh_deyidexiao");
emojiMap.put("[给劲]", "lxh_feijin");
emojiMap.put("[好爱哦]", "lxh_haoaio");
emojiMap.put("[好棒]", "lxh_haobang");
emojiMap.put("[好囧]", "lxh_haojiong");
emojiMap.put("[好喜欢]", "lxh_haoxihuan");
emojiMap.put("[hold住]", "lxh_holdzhu");
emojiMap.put("[杰克逊]", "lxh_jiekexun");
emojiMap.put("[纠结]", "lxh_jiujie");
emojiMap.put("[巨汗]", "lxh_juhan");
emojiMap.put("[抠鼻屎]", "lxh_koubishi");
emojiMap.put("[困死了]", "lxh_kunsile");
emojiMap.put("[雷锋]", "lxh_leifeng");
emojiMap.put("[泪流满面]", "lxh_leiliumanmian");
emojiMap.put("[玫瑰]", "lxh_meigui");
emojiMap.put("[噢耶]", "lxh_oye");
emojiMap.put("[霹雳]", "lxh_pili");
emojiMap.put("[瞧瞧]", "lxh_qiaoqiao");
emojiMap.put("[丘比特]", "lxh_qiubite");
emojiMap.put("[求关注]", "lxh_qiuguanzhu");
emojiMap.put("[群体围观]", "lxh_quntiweiguan");
emojiMap.put("[甩甩手]", "lxh_shuaishuaishou");
emojiMap.put("[偷乐]", "lxh_toule");
emojiMap.put("[推荐]", "lxh_tuijian");
emojiMap.put("[互相膜拜]", "lxh_xianghumobai");
emojiMap.put("[想一想]", "lxh_xiangyixiang");
emojiMap.put("[笑哈哈]", "lxh_xiaohaha");
emojiMap.put("[羞嗒嗒]", "lxh_xiudada");
emojiMap.put("[许愿]", "lxh_xuyuan");
emojiMap.put("[有鸭梨]", "lxh_youyali");
emojiMap.put("[震惊]", "lxh_zhenjing");
emojiMap.put("[转发]", "lxh_zhuanfa");
//其他
emojiMap.put("[蛋糕]", "o_dangao");
emojiMap.put("[飞机]", "o_feiji");
emojiMap.put("[干杯]", "o_ganbei");
emojiMap.put("[话筒]", "o_huatong");
emojiMap.put("[蜡烛]", "o_lazhu");
emojiMap.put("[礼物]", "o_liwu");
emojiMap.put("[围观]", "o_weiguan");
emojiMap.put("[咖啡]", "o_kafei");
emojiMap.put("[足球]", "o_zuqiu");
emojiMap.put("[ok]", "h_ok");
emojiMap.put("[躁狂症]", "lxh_zaokuangzheng");
emojiMap.put("[赞]", "h_zan");
emojiMap.put("[心]", "l_xin");
emojiMap.put("[伤心]", "l_shangxin");
emojiMap.put("[月亮]", "w_yueliang");
emojiMap.put("[鲜花]", "w_xianhua");
emojiMap.put("[太阳]", "w_taiyang");
emojiMap.put("[浮云]", "w_fuyun");
emojiMap.put("[神马]", "f_shenma");
emojiMap.put("[微风]", "w_weifeng");
emojiMap.put("[下雨]", "w_xiayu");
emojiMap.put("[色]", "d_huaxin");
emojiMap.put("[沙尘暴]", "w_shachenbao");
emojiMap.put("[落叶]", "w_luoye");
emojiMap.put("[雪人]", "w_xueren");
emojiMap.put("[good]", "h_good");
emojiMap.put("[哆啦A梦吃惊]", "dorahaose_mobile");
emojiMap.put("[哆啦A梦微笑]", "jqmweixiao_mobile");
emojiMap.put("[哆啦A梦花心]", "dorahaose_mobile");
emojiMap.put("[炸鸡啤酒]", "d_zhajipijiu");
emojiMap.put("[炸鸡和啤酒]", "d_zhajipijiu");
emojiMap.put("[囧]", "jiong");
emojiMap.put("[NO]", "buyao");
emojiMap.put("[来]", "guolai");
emojiMap.put("[互粉]", "f_hufen");
emojiMap.put("[握手]", "h_woshou");
emojiMap.put("[haha]", "h_haha");
emojiMap.put("[织]", "zhi");
emojiMap.put("[萌]", "meng");
emojiMap.put("[钟]", "o_zhong");
emojiMap.put("[喜]", "xi");
emojiMap.put("[绿丝带]", "o_lvsidai");
emojiMap.put("[围脖]", "weibo");
emojiMap.put("[音乐]", "o_yinyue");
emojiMap.put("[照相机]", "o_zhaoxiangji");
emojiMap.put("[耶]", "h_ye");
emojiMap.put("[发红包]", "o_fahongbao1x");
emojiMap.put("[拍照]", "lxhpz_paizhao");
emojiMap.put("[白眼]", "landeln_baiyan");
emojiMap.put("[囧]", "f_jiong");
emojiMap.put("[萌]", "f_meng");
emojiMap.put("[威武]", "f_v5");
emojiMap.put("[喜]", "f_xi");
emojiMap.put("[带着微博去旅行]", "d_travel1x");
emojiMap.put("[不要]", "h_buyao");
emojiMap.put("[织]", "f_zhi");
emojiMap.put("[good]", "h_good");
emojiMap.put("[来]", "h_lai");
emojiMap.put("[弱]", "h_ruo");
emojiMap.put("[围脖]", "o_weibo");
emojiMap.put("[作揖]", "h_zuoyi");
emojiMap.put("[拳头]", "h_quantou");
emojiMap.put("[X教授]", "xman_jiaoshou");
emojiMap.put("[天启]", "xman_tianqi");
emojiMap.put("[抢到啦]", "hb_qiangdao_org");
}
/**
* @param emojiText like [挖鼻]
* @return 返回图片的名字
*/
public static String getImgName(String emojiText) {
String ImgName = emojiMap.get(emojiText);
if (!TextUtils.isEmpty(ImgName)) {
return ImgName;
} else {
return null;
}
}
}
| false |
11799_3 | package com.luck.picture.lib.permissions;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.provider.Settings;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Size;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.Fragment;
import com.luck.picture.lib.utils.SpUtils;
/**
* @author：luck
* @date：2021/11/18 10:12 上午
* @describe：PermissionUtil
*/
public class PermissionUtil {
/**
* 默认未请求授权状态
*/
public static final int DEFAULT = 0;
/**
* 获取权限成功
*/
public static final int SUCCESS = 1;
/**
* 申请权限拒绝, 但是下次申请权限还会弹窗
*/
public static final int REFUSE = 2;
/**
* 申请权限拒绝，并且是永久，不会再弹窗
*/
public static final int REFUSE_PERMANENT = 3;
/**
* Activity Action: Show screen for controlling which apps have access to manage external
* storage.
* <p>
* In some cases, a matching Activity may not exist, so ensure you safeguard against this.
* <p>
* If you want to control a specific app's access to manage external storage, use
* {@link #ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION} instead.
* <p>
* Output: Nothing.
*
* @see #ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION
*/
public static final String ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION =
"android.settings.MANAGE_ALL_FILES_ACCESS_PERMISSION";
public static boolean hasPermissions(@NonNull Context context, @Size(min = 1) @NonNull String... perms) {
if (Build.VERSION.SDK_INT < 23) {
return true;
}
for (String perm : perms) {
if (ContextCompat.checkSelfPermission(context, perm) != PackageManager.PERMISSION_GRANTED) {
return false;
}
}
return true;
}
public static int getPermissionStatus(Activity activity, String permission) {
int flag = ActivityCompat.checkSelfPermission(activity, permission);
boolean should = ActivityCompat.shouldShowRequestPermissionRationale(activity, permission);
if (should) {
return REFUSE;
}
if (flag == PackageManager.PERMISSION_GRANTED) {
return SUCCESS;
}
if (!SpUtils.contains(activity, permission)) {
return DEFAULT;
}
return REFUSE_PERMANENT;
}
public static boolean isAllGranted(Context context, String[] permissions, int[] grantResults) {
boolean isAllGranted = true;
boolean skipPermissionReject = false;
int targetSdkVersion = context.getApplicationInfo().targetSdkVersion;
if (targetSdkVersion >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
if (ContextCompat.checkSelfPermission(context, PermissionConfig.READ_MEDIA_VISUAL_USER_SELECTED) == PackageManager.PERMISSION_GRANTED) {
skipPermissionReject = true;
}
}
if (grantResults.length > 0) {
for (int i = 0; i < grantResults.length; i++) {
if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
if (skipPermissionReject) {
if (permissions[i].equals(PermissionConfig.READ_MEDIA_IMAGES) ||
permissions[i].equals(PermissionConfig.READ_MEDIA_VIDEO)) {
break;
}
}
isAllGranted = false;
break;
}
}
} else {
isAllGranted = false;
}
return isAllGranted;
}
/**
* 跳转到系统设置页面
*/
public static void goIntentSetting(Fragment fragment, int requestCode) {
try {
Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
Uri uri = Uri.fromParts("package", fragment.getActivity().getPackageName(), null);
intent.setData(uri);
fragment.startActivityForResult(intent, requestCode);
} catch (Exception e) {
e.printStackTrace();
}
}
}
| LuckSiege/PictureSelector | selector/src/main/java/com/luck/picture/lib/permissions/PermissionUtil.java | 1,030 | /**
* 申请权限拒绝, 但是下次申请权限还会弹窗
*/ | block_comment | zh-cn | package com.luck.picture.lib.permissions;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.provider.Settings;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Size;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.Fragment;
import com.luck.picture.lib.utils.SpUtils;
/**
* @author：luck
* @date：2021/11/18 10:12 上午
* @describe：PermissionUtil
*/
public class PermissionUtil {
/**
* 默认未请求授权状态
*/
public static final int DEFAULT = 0;
/**
* 获取权限成功
*/
public static final int SUCCESS = 1;
/**
* 申请权 <SUF>*/
public static final int REFUSE = 2;
/**
* 申请权限拒绝，并且是永久，不会再弹窗
*/
public static final int REFUSE_PERMANENT = 3;
/**
* Activity Action: Show screen for controlling which apps have access to manage external
* storage.
* <p>
* In some cases, a matching Activity may not exist, so ensure you safeguard against this.
* <p>
* If you want to control a specific app's access to manage external storage, use
* {@link #ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION} instead.
* <p>
* Output: Nothing.
*
* @see #ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION
*/
public static final String ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION =
"android.settings.MANAGE_ALL_FILES_ACCESS_PERMISSION";
public static boolean hasPermissions(@NonNull Context context, @Size(min = 1) @NonNull String... perms) {
if (Build.VERSION.SDK_INT < 23) {
return true;
}
for (String perm : perms) {
if (ContextCompat.checkSelfPermission(context, perm) != PackageManager.PERMISSION_GRANTED) {
return false;
}
}
return true;
}
public static int getPermissionStatus(Activity activity, String permission) {
int flag = ActivityCompat.checkSelfPermission(activity, permission);
boolean should = ActivityCompat.shouldShowRequestPermissionRationale(activity, permission);
if (should) {
return REFUSE;
}
if (flag == PackageManager.PERMISSION_GRANTED) {
return SUCCESS;
}
if (!SpUtils.contains(activity, permission)) {
return DEFAULT;
}
return REFUSE_PERMANENT;
}
public static boolean isAllGranted(Context context, String[] permissions, int[] grantResults) {
boolean isAllGranted = true;
boolean skipPermissionReject = false;
int targetSdkVersion = context.getApplicationInfo().targetSdkVersion;
if (targetSdkVersion >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
if (ContextCompat.checkSelfPermission(context, PermissionConfig.READ_MEDIA_VISUAL_USER_SELECTED) == PackageManager.PERMISSION_GRANTED) {
skipPermissionReject = true;
}
}
if (grantResults.length > 0) {
for (int i = 0; i < grantResults.length; i++) {
if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
if (skipPermissionReject) {
if (permissions[i].equals(PermissionConfig.READ_MEDIA_IMAGES) ||
permissions[i].equals(PermissionConfig.READ_MEDIA_VIDEO)) {
break;
}
}
isAllGranted = false;
break;
}
}
} else {
isAllGranted = false;
}
return isAllGranted;
}
/**
* 跳转到系统设置页面
*/
public static void goIntentSetting(Fragment fragment, int requestCode) {
try {
Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
Uri uri = Uri.fromParts("package", fragment.getActivity().getPackageName(), null);
intent.setData(uri);
fragment.startActivityForResult(intent, requestCode);
} catch (Exception e) {
e.printStackTrace();
}
}
}
| true |
57975_0 | package com.shizhefei.mutitypedemo.activity;
import android.os.Bundle;
import android.os.PersistableBundle;
import android.support.v4.app.FragmentManager;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.EditText;
import com.shizhefei.mutitypedemo.R;
import com.shizhefei.mutitypedemo.type.Message;
import com.shizhefei.mutitypedemo.type.MessageProvider;
import com.shizhefei.view.multitype.ItemBinderFactory;
import com.shizhefei.view.multitype.ItemViewProviderSet;
import com.shizhefei.view.multitype.MultiTypeAdapter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ChatActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private ItemBinderFactory itemBinderFactory;
private String myUserId = "1";
private MultiTypeAdapter multiTypeAdapter;
private EditText messageEditText;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_chat);
recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, true));
itemBinderFactory = new ItemBinderFactory();
//有时候需要根据TextItem里面的某个字段，生成不同的布局.比如聊天界面的message是一样的，但是有区分左右布局
//ItemProviderSet可以通过数据类型区分无数种情况的Provider
itemBinderFactory.registerProvider(Message.class, new ItemViewProviderSet<Message>(new MessageProvider(MessageProvider.ALIGN_LEFT), new MessageProvider(MessageProvider.ALIGN_RIGHT)) {
@Override
protected int selectIndex(Message message) {
return myUserId.equals(message.userId) ? 1 : 0;
}
});
List<Object> list = load();
Collections.reverse(list);
recyclerView.setAdapter(multiTypeAdapter = new MultiTypeAdapter(list, itemBinderFactory));
messageEditText = (EditText) findViewById(R.id.message_editText);
findViewById(R.id.send_button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String text = messageEditText.getText().toString();
multiTypeAdapter.getData().add(0, new Message(myUserId, text));
multiTypeAdapter.notifyItemInserted(0);
messageEditText.getText().clear();
recyclerView.scrollToPosition(0);
}
});
}
@Override
public void onStateNotSaved() {
super.onStateNotSaved();
FragmentManager fragmentManager;
}
@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
super.onSaveInstanceState(outState, outPersistentState);
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
private List<Object> load() {
List<Object> message = new ArrayList<>();
message.add(new Message("1", "58秒95"));
message.add(new Message("2", "58秒95？"));
message.add(new Message("2", "自己都没想到自己"));
message.add(new Message("2", "我以为是59秒"));
message.add(new Message("2", "啊～～我有这么快？？"));
message.add(new Message("2", "我很满意"));
message.add(new Message("1", "今天这个状态有所保留么？"));
message.add(new Message("2", "没有保留！我已经，我已经用了洪荒之力啦！"));
message.add(new Message("1", "是不是对明天的决赛充满希望"));
message.add(new Message("2", "没有，我已经很满意啦。"));
message.add(new Message("1", "明天加油"));
message.add(new Message("2", "啦。。。啦。。。"));
return message;
}
}
| LuckyJayce/MultiTypeView | app/src/main/java/com/shizhefei/mutitypedemo/activity/ChatActivity.java | 1,029 | //有时候需要根据TextItem里面的某个字段，生成不同的布局.比如聊天界面的message是一样的，但是有区分左右布局 | line_comment | zh-cn | package com.shizhefei.mutitypedemo.activity;
import android.os.Bundle;
import android.os.PersistableBundle;
import android.support.v4.app.FragmentManager;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.widget.EditText;
import com.shizhefei.mutitypedemo.R;
import com.shizhefei.mutitypedemo.type.Message;
import com.shizhefei.mutitypedemo.type.MessageProvider;
import com.shizhefei.view.multitype.ItemBinderFactory;
import com.shizhefei.view.multitype.ItemViewProviderSet;
import com.shizhefei.view.multitype.MultiTypeAdapter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ChatActivity extends AppCompatActivity {
private RecyclerView recyclerView;
private ItemBinderFactory itemBinderFactory;
private String myUserId = "1";
private MultiTypeAdapter multiTypeAdapter;
private EditText messageEditText;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_chat);
recyclerView = (RecyclerView) findViewById(R.id.recyclerView);
recyclerView.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, true));
itemBinderFactory = new ItemBinderFactory();
//有时 <SUF>
//ItemProviderSet可以通过数据类型区分无数种情况的Provider
itemBinderFactory.registerProvider(Message.class, new ItemViewProviderSet<Message>(new MessageProvider(MessageProvider.ALIGN_LEFT), new MessageProvider(MessageProvider.ALIGN_RIGHT)) {
@Override
protected int selectIndex(Message message) {
return myUserId.equals(message.userId) ? 1 : 0;
}
});
List<Object> list = load();
Collections.reverse(list);
recyclerView.setAdapter(multiTypeAdapter = new MultiTypeAdapter(list, itemBinderFactory));
messageEditText = (EditText) findViewById(R.id.message_editText);
findViewById(R.id.send_button).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String text = messageEditText.getText().toString();
multiTypeAdapter.getData().add(0, new Message(myUserId, text));
multiTypeAdapter.notifyItemInserted(0);
messageEditText.getText().clear();
recyclerView.scrollToPosition(0);
}
});
}
@Override
public void onStateNotSaved() {
super.onStateNotSaved();
FragmentManager fragmentManager;
}
@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
super.onSaveInstanceState(outState, outPersistentState);
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
}
private List<Object> load() {
List<Object> message = new ArrayList<>();
message.add(new Message("1", "58秒95"));
message.add(new Message("2", "58秒95？"));
message.add(new Message("2", "自己都没想到自己"));
message.add(new Message("2", "我以为是59秒"));
message.add(new Message("2", "啊～～我有这么快？？"));
message.add(new Message("2", "我很满意"));
message.add(new Message("1", "今天这个状态有所保留么？"));
message.add(new Message("2", "没有保留！我已经，我已经用了洪荒之力啦！"));
message.add(new Message("1", "是不是对明天的决赛充满希望"));
message.add(new Message("2", "没有，我已经很满意啦。"));
message.add(new Message("1", "明天加油"));
message.add(new Message("2", "啦。。。啦。。。"));
return message;
}
}
| true |
41323_2 | package com.shizhefei.indicator.moretab;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.FragmentActivity;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import com.shizhefei.indicator.DisplayUtil;
import com.shizhefei.indicator.demo.R;
import com.shizhefei.view.indicator.IndicatorViewPager;
import com.shizhefei.view.indicator.ScrollIndicatorView;
import com.shizhefei.view.indicator.slidebar.ColorBar;
import com.shizhefei.view.indicator.transition.OnTransitionTextListener;
/**
* Created by LuckyJayce on 2016/6/25.
*/
public class MoreTab2Activity extends FragmentActivity {
private IndicatorViewPager indicatorViewPager;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_moretab2);
ViewPager viewPager = (ViewPager) findViewById(R.id.moretab_viewPager);
ScrollIndicatorView scrollIndicatorView = (ScrollIndicatorView) findViewById(R.id.moretab_indicator);
float unSelectSize = 12;
float selectSize = unSelectSize * 1.3f;
scrollIndicatorView.setOnTransitionListener(new OnTransitionTextListener().setColor(0xFF2196F3, Color.GRAY).setSize(selectSize, unSelectSize));
scrollIndicatorView.setScrollBar(new ColorBar(this, 0xFF2196F3, 4));
viewPager.setOffscreenPageLimit(2);
indicatorViewPager = new IndicatorViewPager(scrollIndicatorView, viewPager);
indicatorViewPager.setAdapter(new MyAdapter());
}
private class MyAdapter extends IndicatorViewPager.IndicatorViewPagerAdapter {
private String[] versions = {"Cupcake", "Donut", "Éclair", "Froyo", "Gingerbread", "Honeycomb", "Ice Cream Sandwich", "Jelly Bean", "KitKat", "Lolipop", "Marshmallow"};
private String[] names = {"纸杯蛋糕", "甜甜圈", "闪电泡芙", "冻酸奶", "姜饼", "蜂巢", "冰激凌三明治", "果冻豆", "奇巧巧克力棒", "棒棒糖", "棉花糖"};
@Override
public int getCount() {
return versions.length;
}
@Override
public View getViewForTab(int position, View convertView, ViewGroup container) {
if (convertView == null) {
convertView = getLayoutInflater().inflate(R.layout.tab_top, container, false);
}
TextView textView = (TextView) convertView;
textView.setText(versions[position]);
int witdh = getTextWidth(textView);
int padding = DisplayUtil.dipToPix(getApplicationContext(), 8);
//因为wrap的布局 字体大小变化会导致textView大小变化产生抖动，这里通过设置textView宽度就避免抖动现象
//1.3f是根据上面字体大小变化的倍数1.3f设置
textView.setWidth((int) (witdh * 1.3f) + padding);
return convertView;
}
@Override
public View getViewForPage(int position, View convertView, ViewGroup container) {
if (convertView == null) {
convertView = new TextView(container.getContext());
}
TextView textView = (TextView) convertView;
textView.setText(names[position]);
textView.setGravity(Gravity.CENTER);
textView.setTextColor(Color.GRAY);
return convertView;
}
@Override
public int getItemPosition(Object object) {
//这是ViewPager适配器的特点,有两个值 POSITION_NONE，POSITION_UNCHANGED，默认就是POSITION_UNCHANGED,
// 表示数据没变化不用更新.notifyDataChange的时候重新调用getViewForPage
return PagerAdapter.POSITION_UNCHANGED;
}
private int getTextWidth(TextView textView) {
if (textView == null) {
return 0;
}
Rect bounds = new Rect();
String text = textView.getText().toString();
Paint paint = textView.getPaint();
paint.getTextBounds(text, 0, text.length(), bounds);
int width = bounds.left + bounds.width();
return width;
}
}
}
| LuckyJayce/ViewPagerIndicator | app/src/main/java/com/shizhefei/indicator/moretab/MoreTab2Activity.java | 1,111 | //1.3f是根据上面字体大小变化的倍数1.3f设置 | line_comment | zh-cn | package com.shizhefei.indicator.moretab;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.FragmentActivity;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import com.shizhefei.indicator.DisplayUtil;
import com.shizhefei.indicator.demo.R;
import com.shizhefei.view.indicator.IndicatorViewPager;
import com.shizhefei.view.indicator.ScrollIndicatorView;
import com.shizhefei.view.indicator.slidebar.ColorBar;
import com.shizhefei.view.indicator.transition.OnTransitionTextListener;
/**
* Created by LuckyJayce on 2016/6/25.
*/
public class MoreTab2Activity extends FragmentActivity {
private IndicatorViewPager indicatorViewPager;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_moretab2);
ViewPager viewPager = (ViewPager) findViewById(R.id.moretab_viewPager);
ScrollIndicatorView scrollIndicatorView = (ScrollIndicatorView) findViewById(R.id.moretab_indicator);
float unSelectSize = 12;
float selectSize = unSelectSize * 1.3f;
scrollIndicatorView.setOnTransitionListener(new OnTransitionTextListener().setColor(0xFF2196F3, Color.GRAY).setSize(selectSize, unSelectSize));
scrollIndicatorView.setScrollBar(new ColorBar(this, 0xFF2196F3, 4));
viewPager.setOffscreenPageLimit(2);
indicatorViewPager = new IndicatorViewPager(scrollIndicatorView, viewPager);
indicatorViewPager.setAdapter(new MyAdapter());
}
private class MyAdapter extends IndicatorViewPager.IndicatorViewPagerAdapter {
private String[] versions = {"Cupcake", "Donut", "Éclair", "Froyo", "Gingerbread", "Honeycomb", "Ice Cream Sandwich", "Jelly Bean", "KitKat", "Lolipop", "Marshmallow"};
private String[] names = {"纸杯蛋糕", "甜甜圈", "闪电泡芙", "冻酸奶", "姜饼", "蜂巢", "冰激凌三明治", "果冻豆", "奇巧巧克力棒", "棒棒糖", "棉花糖"};
@Override
public int getCount() {
return versions.length;
}
@Override
public View getViewForTab(int position, View convertView, ViewGroup container) {
if (convertView == null) {
convertView = getLayoutInflater().inflate(R.layout.tab_top, container, false);
}
TextView textView = (TextView) convertView;
textView.setText(versions[position]);
int witdh = getTextWidth(textView);
int padding = DisplayUtil.dipToPix(getApplicationContext(), 8);
//因为wrap的布局 字体大小变化会导致textView大小变化产生抖动，这里通过设置textView宽度就避免抖动现象
//1. <SUF>
textView.setWidth((int) (witdh * 1.3f) + padding);
return convertView;
}
@Override
public View getViewForPage(int position, View convertView, ViewGroup container) {
if (convertView == null) {
convertView = new TextView(container.getContext());
}
TextView textView = (TextView) convertView;
textView.setText(names[position]);
textView.setGravity(Gravity.CENTER);
textView.setTextColor(Color.GRAY);
return convertView;
}
@Override
public int getItemPosition(Object object) {
//这是ViewPager适配器的特点,有两个值 POSITION_NONE，POSITION_UNCHANGED，默认就是POSITION_UNCHANGED,
// 表示数据没变化不用更新.notifyDataChange的时候重新调用getViewForPage
return PagerAdapter.POSITION_UNCHANGED;
}
private int getTextWidth(TextView textView) {
if (textView == null) {
return 0;
}
Rect bounds = new Rect();
String text = textView.getText().toString();
Paint paint = textView.getPaint();
paint.getTextBounds(text, 0, text.length(), bounds);
int width = bounds.left + bounds.width();
return width;
}
}
}
| true |
23749_0 | package com.wen.seckill.rabbitmq;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
//原谅我把。。这个类是我copy的。不是手写的。太多交换机模式了，蛋疼，只学了默认的
@Configuration
public class MQConfig {
public static final String MIAOSHA_QUEUE = "hello";
public static final String QUEUE = "queue";
public static final String TOPIC_QUEUE1 = "topic.queue1";
public static final String TOPIC_QUEUE2 = "topic.queue2";
public static final String HEADER_QUEUE = "header.queue";
public static final String TOPIC_EXCHANGE = "topicExchage";
public static final String FANOUT_EXCHANGE = "fanoutExchage";
public static final String HEADERS_EXCHANGE = "headersExchage";
/**
* Direct模式 交换机 Exchange
* */
@Bean
public Queue queue() {
return new Queue(QUEUE, true);
}
/**
* Topic模式 交换机Exchange
* */
@Bean
public Queue topicQueue1() {
return new Queue(TOPIC_QUEUE1, true);
}
@Bean
public Queue topicQueue2() {
return new Queue(TOPIC_QUEUE2, true);
}
@Bean
public TopicExchange topicExchage(){
return new TopicExchange(TOPIC_EXCHANGE);
}
@Bean
public Binding topicBinding1() {
return BindingBuilder.bind(topicQueue1()).to(topicExchage()).with("topic.key1");
}
@Bean
public Binding topicBinding2() {
return BindingBuilder.bind(topicQueue2()).to(topicExchage()).with("topic.#");
}
/**
* Fanout模式(广播模式) 交换机Exchange
* */
@Bean
public FanoutExchange fanoutExchage(){
return new FanoutExchange(FANOUT_EXCHANGE);
}
@Bean
public Binding FanoutBinding1() {
return BindingBuilder.bind(topicQueue1()).to(fanoutExchage());
}
@Bean
public Binding FanoutBinding2() {
return BindingBuilder.bind(topicQueue2()).to(fanoutExchage());
}
/**
* Header模式 交换机Exchange
* */
@Bean
public HeadersExchange headersExchage(){
return new HeadersExchange(HEADERS_EXCHANGE);
}
@Bean
public Queue headerQueue1() {
return new Queue(HEADER_QUEUE, true);
}
@Bean
public Binding headerBinding() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("header1", "value1");
map.put("header2", "value2");
return BindingBuilder.bind(headerQueue1()).to(headersExchage()).whereAll(map).match();
}
}
| LuckyToMeet-Dian-N/myseckill | src/main/java/com/wen/seckill/rabbitmq/MQConfig.java | 765 | //原谅我把。。这个类是我copy的。不是手写的。太多交换机模式了，蛋疼，只学了默认的 | line_comment | zh-cn | package com.wen.seckill.rabbitmq;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
//原谅 <SUF>
@Configuration
public class MQConfig {
public static final String MIAOSHA_QUEUE = "hello";
public static final String QUEUE = "queue";
public static final String TOPIC_QUEUE1 = "topic.queue1";
public static final String TOPIC_QUEUE2 = "topic.queue2";
public static final String HEADER_QUEUE = "header.queue";
public static final String TOPIC_EXCHANGE = "topicExchage";
public static final String FANOUT_EXCHANGE = "fanoutExchage";
public static final String HEADERS_EXCHANGE = "headersExchage";
/**
* Direct模式 交换机 Exchange
* */
@Bean
public Queue queue() {
return new Queue(QUEUE, true);
}
/**
* Topic模式 交换机Exchange
* */
@Bean
public Queue topicQueue1() {
return new Queue(TOPIC_QUEUE1, true);
}
@Bean
public Queue topicQueue2() {
return new Queue(TOPIC_QUEUE2, true);
}
@Bean
public TopicExchange topicExchage(){
return new TopicExchange(TOPIC_EXCHANGE);
}
@Bean
public Binding topicBinding1() {
return BindingBuilder.bind(topicQueue1()).to(topicExchage()).with("topic.key1");
}
@Bean
public Binding topicBinding2() {
return BindingBuilder.bind(topicQueue2()).to(topicExchage()).with("topic.#");
}
/**
* Fanout模式(广播模式) 交换机Exchange
* */
@Bean
public FanoutExchange fanoutExchage(){
return new FanoutExchange(FANOUT_EXCHANGE);
}
@Bean
public Binding FanoutBinding1() {
return BindingBuilder.bind(topicQueue1()).to(fanoutExchage());
}
@Bean
public Binding FanoutBinding2() {
return BindingBuilder.bind(topicQueue2()).to(fanoutExchage());
}
/**
* Header模式 交换机Exchange
* */
@Bean
public HeadersExchange headersExchage(){
return new HeadersExchange(HEADERS_EXCHANGE);
}
@Bean
public Queue headerQueue1() {
return new Queue(HEADER_QUEUE, true);
}
@Bean
public Binding headerBinding() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("header1", "value1");
map.put("header2", "value2");
return BindingBuilder.bind(headerQueue1()).to(headersExchage()).whereAll(map).match();
}
}
| false |
9935_1 | package com.dream.service;
import com.dream.po.User;
public interface UserService {
// 编辑用户（好像暂未用到?谁写的）
public User getUserById(Integer id);
// 更新用户信息用于修改密码
public void updateUser(Integer userid, String password, String email);
}
| LuckyZXL2016/Movie_Recommend | Movie/src/main/java/com/dream/service/UserService.java | 77 | // 更新用户信息用于修改密码 | line_comment | zh-cn | package com.dream.service;
import com.dream.po.User;
public interface UserService {
// 编辑用户（好像暂未用到?谁写的）
public User getUserById(Integer id);
// 更新 <SUF>
public void updateUser(Integer userid, String password, String email);
}
| true |
22557_1 | import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class Yard extends Frame {
PaintThread paintThread = new PaintThread();
private boolean gameOver = false;
public static final int ROWS = 30;
public static final int COLS = 30;
public static final int BLOCK_SIZE = 15;
private Font fontGameOver = new Font("宋体", Font.BOLD, 50);
private int score = 0;
Snake s = new Snake(this);
Egg e = new Egg();
Image offScreenImage = null;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void launch() {
this.setLocation(200, 200);
this.setSize(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
//使退出键有效果
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
this.setVisible(true);
this.addKeyListener(new KeyMonitor());
new Thread(paintThread).start();
}
public static void main(String[] args) {
new Yard().launch();
}
public void stop() {
gameOver = true;
}
public void paint(Graphics g) {
Color c = g.getColor();
g.setColor(Color.GRAY);
g.fillRect(0, 0, COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
g.setColor(Color.DARK_GRAY);
//画出横线
for(int i=1; i<ROWS; i++) {
g.drawLine(0, BLOCK_SIZE * i, COLS * BLOCK_SIZE, BLOCK_SIZE * i);
}
for(int i=1; i<COLS; i++) {
g.drawLine(BLOCK_SIZE * i, 0, BLOCK_SIZE * i, BLOCK_SIZE * ROWS);
}
g.setColor(Color.YELLOW);
g.drawString("score:" + score, 10, 60);
if(gameOver) {
g.setFont(fontGameOver);
g.drawString("游戏结束", 120, 180);
paintThread.pause();
}
g.setColor(c);
s.eat(e);
e.draw(g);
s.draw(g);
}
public void update(Graphics g) {
if(offScreenImage == null) {
offScreenImage = this.createImage(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE );
}
Graphics gOff = offScreenImage.getGraphics();
paint(gOff);
g.drawImage(offScreenImage, 0, 0, null);
}
private class PaintThread implements Runnable {
private boolean pause = false;
private boolean running = true;
public void run() {
while(running) {
if(pause) continue;
else repaint();
try {
Thread.sleep(200); //回调paint()方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void pause() {
this.pause = true;
}
public void reStart() {
this.pause = false;
s = new Snake(Yard.this);
gameOver = false;
}
public void gameOver() {
running = false;
}
}
private class KeyMonitor extends KeyAdapter {
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if(key == KeyEvent.VK_F2) {
paintThread.reStart();
}
s.keyPressed(e);
}
}
}
| LuckyZXL2016/Snake | src/Yard.java | 1,056 | //画出横线
| line_comment | zh-cn | import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class Yard extends Frame {
PaintThread paintThread = new PaintThread();
private boolean gameOver = false;
public static final int ROWS = 30;
public static final int COLS = 30;
public static final int BLOCK_SIZE = 15;
private Font fontGameOver = new Font("宋体", Font.BOLD, 50);
private int score = 0;
Snake s = new Snake(this);
Egg e = new Egg();
Image offScreenImage = null;
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void launch() {
this.setLocation(200, 200);
this.setSize(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
//使退出键有效果
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
this.setVisible(true);
this.addKeyListener(new KeyMonitor());
new Thread(paintThread).start();
}
public static void main(String[] args) {
new Yard().launch();
}
public void stop() {
gameOver = true;
}
public void paint(Graphics g) {
Color c = g.getColor();
g.setColor(Color.GRAY);
g.fillRect(0, 0, COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);
g.setColor(Color.DARK_GRAY);
//画出 <SUF>
for(int i=1; i<ROWS; i++) {
g.drawLine(0, BLOCK_SIZE * i, COLS * BLOCK_SIZE, BLOCK_SIZE * i);
}
for(int i=1; i<COLS; i++) {
g.drawLine(BLOCK_SIZE * i, 0, BLOCK_SIZE * i, BLOCK_SIZE * ROWS);
}
g.setColor(Color.YELLOW);
g.drawString("score:" + score, 10, 60);
if(gameOver) {
g.setFont(fontGameOver);
g.drawString("游戏结束", 120, 180);
paintThread.pause();
}
g.setColor(c);
s.eat(e);
e.draw(g);
s.draw(g);
}
public void update(Graphics g) {
if(offScreenImage == null) {
offScreenImage = this.createImage(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE );
}
Graphics gOff = offScreenImage.getGraphics();
paint(gOff);
g.drawImage(offScreenImage, 0, 0, null);
}
private class PaintThread implements Runnable {
private boolean pause = false;
private boolean running = true;
public void run() {
while(running) {
if(pause) continue;
else repaint();
try {
Thread.sleep(200); //回调paint()方法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void pause() {
this.pause = true;
}
public void reStart() {
this.pause = false;
s = new Snake(Yard.this);
gameOver = false;
}
public void gameOver() {
running = false;
}
}
private class KeyMonitor extends KeyAdapter {
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if(key == KeyEvent.VK_F2) {
paintThread.reStart();
}
s.keyPressed(e);
}
}
}
| false |
35241_1 | package com.tank;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* 这个类的作用是坦克游戏的主窗口
* @author zhangxilin
*
*/
public class TankClient extends Frame {
/**
* 整个坦克游戏的宽度
*/
public static final int GAME_WIDTH = 800;
public static final int GAME_HEIGHT = 600;
Tank myTank = new Tank(300, 250, true, Direction.STOP, this);
Wall w1 = new Wall(100, 200, 20, 150 ,this), w2 = new Wall(300, 100, 300, 20, this);
List<Explode> explodes = new ArrayList<Explode>();
List<Missile> missiles = new ArrayList<Missile>();
List<Tank> tanks = new ArrayList<Tank>();
Image offScreenImage = null;
Blood b = new Blood();
public void paint(Graphics g) {
/*
* 指明子弹-爆炸-坦克的数量
* 以及坦克的生命值
*/
g.drawString("missiles count:" + missiles.size(), 10, 50);
g.drawString("explodes count:" + explodes.size(), 10, 70);
g.drawString("tanks count:" + tanks.size(), 10, 90);
g.drawString("tanks life:" + myTank.getLife(), 10, 110);
if(tanks.size() <= 0) {
for(int i=0; i<Integer.parseInt(PropertyMgr.getProperty("reProduceTankCount")); i++) {
tanks.add(new Tank(50 + 40*(i+1), 50, false, Direction.D, this));
}
}
for(int i=0; i<missiles.size(); i++) {
Missile m = missiles.get(i);
m.hitTanks(tanks);
m.hitTank(myTank);
m.hitWall(w1);
m.hitWall(w2);
m.draw(g);
//if(!m.isLive()) missiles.remove(m);
//else m.draw(g);
}
for(int i = 0; i<explodes.size(); i++) {
Explode e = explodes.get(i);
e.draw(g);
}
for(int i= 0;i<tanks.size(); i++) {
Tank t = tanks.get(i);
t.collidesWithWall(w1);
t.collidesWithWall(w2);
t.collidesWithTanks(tanks);
t.draw(g);
}
myTank.draw(g);
myTank.eat(b);
w1.draw(g);
w2.draw(g);
b.draw(g);
}
public void update(Graphics g) {
if(offScreenImage == null) {
offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT); //创建图片
}
//获得该图片的画笔
Graphics gOffScreen = offScreenImage.getGraphics();
Color c = gOffScreen.getColor();
gOffScreen.setColor(Color.GREEN);
gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
gOffScreen.setColor(c);
paint(gOffScreen);
g.drawImage(offScreenImage, 0, 0, null);
}
/**
* 本方法显示坦克主窗口
*
*/
public void lauchFrame() {
int initTankCount = Integer.parseInt(PropertyMgr.getProperty("initTankCount"));
System.out.println(initTankCount);
for(int i=0; i<initTankCount; i++) {
tanks.add(new Tank(50 + 40*(i+1), 50, false, Direction.D, this));
}
this.setLocation(400, 100);
this.setSize(GAME_WIDTH, GAME_HEIGHT);
this.setTitle("TankWar");
//使用匿名类可以关闭窗口
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
this.setResizable(false);
//设置背景颜色
this.setBackground(Color.GREEN);
this.addKeyListener(new KeyMonitor());
setVisible(true);
new Thread(new PaintThread()).start();
}
public static void main(String[] args) {
TankClient tc = new TankClient();
tc.lauchFrame();
}
private class PaintThread implements Runnable {
public void run() {
while(true) {
repaint(); //调用的外部类即TankWar的paint()方法， repaint()首先调用update()方法，再调用paint()方法
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
private class KeyMonitor extends KeyAdapter {
public void keyReleased(KeyEvent e) {
myTank.keyReleased(e);
}
public void keyPressed(KeyEvent e) {
myTank.KeyPressed(e);
}
}
}
| LuckyZXL2016/TankWar | src/com/tank/TankClient.java | 1,472 | /**
* 整个坦克游戏的宽度
*/ | block_comment | zh-cn | package com.tank;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
* 这个类的作用是坦克游戏的主窗口
* @author zhangxilin
*
*/
public class TankClient extends Frame {
/**
* 整个坦 <SUF>*/
public static final int GAME_WIDTH = 800;
public static final int GAME_HEIGHT = 600;
Tank myTank = new Tank(300, 250, true, Direction.STOP, this);
Wall w1 = new Wall(100, 200, 20, 150 ,this), w2 = new Wall(300, 100, 300, 20, this);
List<Explode> explodes = new ArrayList<Explode>();
List<Missile> missiles = new ArrayList<Missile>();
List<Tank> tanks = new ArrayList<Tank>();
Image offScreenImage = null;
Blood b = new Blood();
public void paint(Graphics g) {
/*
* 指明子弹-爆炸-坦克的数量
* 以及坦克的生命值
*/
g.drawString("missiles count:" + missiles.size(), 10, 50);
g.drawString("explodes count:" + explodes.size(), 10, 70);
g.drawString("tanks count:" + tanks.size(), 10, 90);
g.drawString("tanks life:" + myTank.getLife(), 10, 110);
if(tanks.size() <= 0) {
for(int i=0; i<Integer.parseInt(PropertyMgr.getProperty("reProduceTankCount")); i++) {
tanks.add(new Tank(50 + 40*(i+1), 50, false, Direction.D, this));
}
}
for(int i=0; i<missiles.size(); i++) {
Missile m = missiles.get(i);
m.hitTanks(tanks);
m.hitTank(myTank);
m.hitWall(w1);
m.hitWall(w2);
m.draw(g);
//if(!m.isLive()) missiles.remove(m);
//else m.draw(g);
}
for(int i = 0; i<explodes.size(); i++) {
Explode e = explodes.get(i);
e.draw(g);
}
for(int i= 0;i<tanks.size(); i++) {
Tank t = tanks.get(i);
t.collidesWithWall(w1);
t.collidesWithWall(w2);
t.collidesWithTanks(tanks);
t.draw(g);
}
myTank.draw(g);
myTank.eat(b);
w1.draw(g);
w2.draw(g);
b.draw(g);
}
public void update(Graphics g) {
if(offScreenImage == null) {
offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT); //创建图片
}
//获得该图片的画笔
Graphics gOffScreen = offScreenImage.getGraphics();
Color c = gOffScreen.getColor();
gOffScreen.setColor(Color.GREEN);
gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
gOffScreen.setColor(c);
paint(gOffScreen);
g.drawImage(offScreenImage, 0, 0, null);
}
/**
* 本方法显示坦克主窗口
*
*/
public void lauchFrame() {
int initTankCount = Integer.parseInt(PropertyMgr.getProperty("initTankCount"));
System.out.println(initTankCount);
for(int i=0; i<initTankCount; i++) {
tanks.add(new Tank(50 + 40*(i+1), 50, false, Direction.D, this));
}
this.setLocation(400, 100);
this.setSize(GAME_WIDTH, GAME_HEIGHT);
this.setTitle("TankWar");
//使用匿名类可以关闭窗口
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
this.setResizable(false);
//设置背景颜色
this.setBackground(Color.GREEN);
this.addKeyListener(new KeyMonitor());
setVisible(true);
new Thread(new PaintThread()).start();
}
public static void main(String[] args) {
TankClient tc = new TankClient();
tc.lauchFrame();
}
private class PaintThread implements Runnable {
public void run() {
while(true) {
repaint(); //调用的外部类即TankWar的paint()方法， repaint()首先调用update()方法，再调用paint()方法
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
private class KeyMonitor extends KeyAdapter {
public void keyReleased(KeyEvent e) {
myTank.keyReleased(e);
}
public void keyPressed(KeyEvent e) {
myTank.KeyPressed(e);
}
}
}
| true |
15343_4 | package run1;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.lang.Math;
public class run1{
//跑道的四个角的经纬度坐标
final double[][] way={
{0，0},
{0，0},
{0，0},
{0，0}
};
double x,y;
int times;//循环次数，一圈分为80个坐标点
public run1(){
this.x=way[0][0];
this.y=way[0][1];
this.times=0;
}
//计算下一个点坐标，将跑道的一圈分为80个点
public void setNextXY(){
int n=times%20,m=times/20;//第n个点
int k=(m+1)%4;
//加入随机数模拟跑步
this.x=(way[k][0]-way[m][0])/20.0*(double)n+way[m][0]+Math.random()/10000;
this.y=(way[k][1]-way[m][1])/20.0*(double)n+way[m][1]+Math.random()/10000;
times++;
if(times==80) times=0;
}
//将坐标字符串写入到剪切版
public void setStr(double x,double y){
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();//获取系统剪切板
String str;//设置字符串
str= String.format("%.6f",x) +","+ String.format("%.6f",y);
StringSelection selection = new StringSelection(str);//构建String数据类型
clipboard.setContents(selection, null);//添加文本到系统剪切板
System.out.println(str);
}
//先点击输入框再按键 ctrl+A 再ctrl+V，用新坐标覆盖原来的坐标；
public void enter() throws AWTException, InterruptedException {
Robot ro=new Robot();
ro.mousePress(InputEvent.BUTTON2_MASK);
Thread.sleep(100);
ro.mouseRelease(InputEvent.BUTTON2_MASK);
Thread.sleep(100);
ro.keyPress(KeyEvent.VK_CONTROL);
ro.keyPress(KeyEvent.VK_A);
Thread.sleep(100);
ro.keyRelease(KeyEvent.VK_A);
ro.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(100);
ro.keyPress(KeyEvent.VK_CONTROL);
ro.keyPress(KeyEvent.VK_V);
Thread.sleep(100);
ro.keyRelease(KeyEvent.VK_V);
ro.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(100);
ro.keyPress(KeyEvent.VK_ENTER);
Thread.sleep(100);
ro.keyRelease(KeyEvent.VK_ENTER);
}
public static void main(String[] args) throws AWTException, InterruptedException {
run1 r = new run1();
Robot ro = new Robot();
ro.delay(10000);//准备时间
int i=350;
while (i-->0) {
r.setNextXY();
r.setStr(r.x, r.y);
r.enter();
ro.delay(500);//速度
}
}
}
| Luhil/auto-run | run1.java | 818 | //加入随机数模拟跑步
| line_comment | zh-cn | package run1;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.lang.Math;
public class run1{
//跑道的四个角的经纬度坐标
final double[][] way={
{0，0},
{0，0},
{0，0},
{0，0}
};
double x,y;
int times;//循环次数，一圈分为80个坐标点
public run1(){
this.x=way[0][0];
this.y=way[0][1];
this.times=0;
}
//计算下一个点坐标，将跑道的一圈分为80个点
public void setNextXY(){
int n=times%20,m=times/20;//第n个点
int k=(m+1)%4;
//加入 <SUF>
this.x=(way[k][0]-way[m][0])/20.0*(double)n+way[m][0]+Math.random()/10000;
this.y=(way[k][1]-way[m][1])/20.0*(double)n+way[m][1]+Math.random()/10000;
times++;
if(times==80) times=0;
}
//将坐标字符串写入到剪切版
public void setStr(double x,double y){
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();//获取系统剪切板
String str;//设置字符串
str= String.format("%.6f",x) +","+ String.format("%.6f",y);
StringSelection selection = new StringSelection(str);//构建String数据类型
clipboard.setContents(selection, null);//添加文本到系统剪切板
System.out.println(str);
}
//先点击输入框再按键 ctrl+A 再ctrl+V，用新坐标覆盖原来的坐标；
public void enter() throws AWTException, InterruptedException {
Robot ro=new Robot();
ro.mousePress(InputEvent.BUTTON2_MASK);
Thread.sleep(100);
ro.mouseRelease(InputEvent.BUTTON2_MASK);
Thread.sleep(100);
ro.keyPress(KeyEvent.VK_CONTROL);
ro.keyPress(KeyEvent.VK_A);
Thread.sleep(100);
ro.keyRelease(KeyEvent.VK_A);
ro.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(100);
ro.keyPress(KeyEvent.VK_CONTROL);
ro.keyPress(KeyEvent.VK_V);
Thread.sleep(100);
ro.keyRelease(KeyEvent.VK_V);
ro.keyRelease(KeyEvent.VK_CONTROL);
Thread.sleep(100);
ro.keyPress(KeyEvent.VK_ENTER);
Thread.sleep(100);
ro.keyRelease(KeyEvent.VK_ENTER);
}
public static void main(String[] args) throws AWTException, InterruptedException {
run1 r = new run1();
Robot ro = new Robot();
ro.delay(10000);//准备时间
int i=350;
while (i-->0) {
r.setNextXY();
r.setStr(r.x, r.y);
r.enter();
ro.delay(500);//速度
}
}
}
| true |
45295_8 | public class Main {
public static double fitness(Individual a) {//适应度函数
int j[]=decode(a.gene);
a.fitness = 1-Math.abs(Environment.need_oxy_all[j[0]] - Environment.env_oxy_all[dlt.getOxygenLevel()])*0.005-Math.abs(Environment.need_moi_all[j[1]]-Environment.env_moi_all[dlt.getHumidity()])*0.01-Math.abs(j[2]-dlt.getFood())*0.1-Math.abs(j[3]-dlt.getTemperature())*0.01+0.01*j[4]+0.01*j[5];
return a.fitness;//临时修改
}
public static int[] decode(boolean[][] a) {//解码
int[] h=new int[a.length];
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++) {
if(a[i][j]) {
if(j==0) h[i]+=1;
else h[i]+=j*2;
}
}
}
return h;
}
private static Population pop;
private static Environment dlt;
public static int generationNumber=0;
public static void main(String args[]){//主方法
//Set up population
dlt=new Environment();
Fenestra allah = new Fenestra(dlt);
while(Fenestra.connection==0){
}
pop = new Population(100);
double lastBestFitness = 0.0;
while(true){
//计算适应度
for (int i = 0; i< Population.setOfIndividual.size(); i++){
if(fitness((Individual) Population.setOfIndividual.get(i))<0)
Population.setOfIndividual.remove(i);//去除适应度小于0个体
}
//排序
//Individual temp = (Individual)(Population.setOfIndividual.firstElement());
Individual[] beforeSort=new Individual[Population.setOfIndividual.size()];
for(int i=0;i<Population.setOfIndividual.size();i++){
beforeSort[i]=(Individual) Population.setOfIndividual.get(i);
}
Individual[] afterSort=new Individual[Population.setOfIndividual.size()];
Quick.sort(beforeSort,0,Population.setOfIndividual.size()-1,afterSort);
for(int j=0;j<afterSort.length;j++){
System.out.println(afterSort[j].fitness);
}
//赋值给原Vector
Population.setOfIndividual.clear();
for (Individual a : afterSort)
Population.setOfIndividual.add(a);
//结束检测：当最大适应度变化小于0.01时终止（需要确认）
Individual Best = (Individual)(Population.setOfIndividual.lastElement());
if(Best.getFitness()-lastBestFitness<0.01)
if(Best.getFitness()<lastBestFitness) {
System.out.println("**适应度出现减少");
lastBestFitness = Best.getFitness();
generationNumber++;
System.out.println("第"+generationNumber+"代结束————————————\n");
EndFenestra aallsah = new EndFenestra("**适应度出现减少","一代结束");
}
else{
int[] bestGene=Main.decode(Best.getGene());
int b=0;
for(int i:bestGene) b=b*10+i;
generationNumber++;
System.out.println("第"+generationNumber+"代结束————————————\n");
System.out.println("最好的基因："+b);
System.out.println();
System.out.println("需氧量："+Environment.need_oxy_all[bestGene[0]]);
System.out.println("湿度要求："+Environment.need_moi_all[bestGene[1]]);
System.out.println("食物需求："+Environment.need_food_all[bestGene[2]]);
System.out.println("温度需求："+Environment.need_tem_first_all[bestGene[3]]+"-"+Environment.need_tem_second_all[bestGene[3]]);
System.out.println("速度："+bestGene[4]);
System.out.println("耐力："+bestGene[5]);
System.out.println();
double z = Best.getFitness();
System.out.println("流程结束");
EndFenestra aallah = new EndFenestra("流程结束",z,b); //结束
break;
}
else{
lastBestFitness = Best.getFitness();
generationNumber++;
System.out.println("第"+generationNumber+"代结束————————————\n");
EndFenestra aawllsah = new EndFenestra("流程进行中","一代结束");
}
//处♂刑所有弱子个体
for(int i = Population.setOfIndividual.capacity()/2 -1; i< Population.setOfIndividual.size(); )
Population.setOfIndividual.remove(0);
//繁殖
int reproduceSize = Population.setOfIndividual.size();
while(Population.setOfIndividual.size() < Population.setOfIndividual.capacity() && reproduceSize!=0){
for(int i = 0;i<reproduceSize-1;i+=2){
Population.setOfIndividual.add(Event.reproduce((Individual) Population.setOfIndividual.get(i),(Individual) Population.setOfIndividual.get(i+1)));
}
reproduceSize /= 2 ;
if(reproduceSize <= 1)//解决剩下1个个体无法繁殖的问题
Population.setOfIndividual.add(Event.reproduce((Individual) Population.setOfIndividual.get(Population.setOfIndividual.size()-1),(Individual) Population.setOfIndividual.get(Population.setOfIndividual.size()-2)));
}
}
}
}
| Luke-lujunxian/Amazing-animals | src/Main.java | 1,444 | //结束检测：当最大适应度变化小于0.01时终止（需要确认） | line_comment | zh-cn | public class Main {
public static double fitness(Individual a) {//适应度函数
int j[]=decode(a.gene);
a.fitness = 1-Math.abs(Environment.need_oxy_all[j[0]] - Environment.env_oxy_all[dlt.getOxygenLevel()])*0.005-Math.abs(Environment.need_moi_all[j[1]]-Environment.env_moi_all[dlt.getHumidity()])*0.01-Math.abs(j[2]-dlt.getFood())*0.1-Math.abs(j[3]-dlt.getTemperature())*0.01+0.01*j[4]+0.01*j[5];
return a.fitness;//临时修改
}
public static int[] decode(boolean[][] a) {//解码
int[] h=new int[a.length];
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++) {
if(a[i][j]) {
if(j==0) h[i]+=1;
else h[i]+=j*2;
}
}
}
return h;
}
private static Population pop;
private static Environment dlt;
public static int generationNumber=0;
public static void main(String args[]){//主方法
//Set up population
dlt=new Environment();
Fenestra allah = new Fenestra(dlt);
while(Fenestra.connection==0){
}
pop = new Population(100);
double lastBestFitness = 0.0;
while(true){
//计算适应度
for (int i = 0; i< Population.setOfIndividual.size(); i++){
if(fitness((Individual) Population.setOfIndividual.get(i))<0)
Population.setOfIndividual.remove(i);//去除适应度小于0个体
}
//排序
//Individual temp = (Individual)(Population.setOfIndividual.firstElement());
Individual[] beforeSort=new Individual[Population.setOfIndividual.size()];
for(int i=0;i<Population.setOfIndividual.size();i++){
beforeSort[i]=(Individual) Population.setOfIndividual.get(i);
}
Individual[] afterSort=new Individual[Population.setOfIndividual.size()];
Quick.sort(beforeSort,0,Population.setOfIndividual.size()-1,afterSort);
for(int j=0;j<afterSort.length;j++){
System.out.println(afterSort[j].fitness);
}
//赋值给原Vector
Population.setOfIndividual.clear();
for (Individual a : afterSort)
Population.setOfIndividual.add(a);
//结束 <SUF>
Individual Best = (Individual)(Population.setOfIndividual.lastElement());
if(Best.getFitness()-lastBestFitness<0.01)
if(Best.getFitness()<lastBestFitness) {
System.out.println("**适应度出现减少");
lastBestFitness = Best.getFitness();
generationNumber++;
System.out.println("第"+generationNumber+"代结束————————————\n");
EndFenestra aallsah = new EndFenestra("**适应度出现减少","一代结束");
}
else{
int[] bestGene=Main.decode(Best.getGene());
int b=0;
for(int i:bestGene) b=b*10+i;
generationNumber++;
System.out.println("第"+generationNumber+"代结束————————————\n");
System.out.println("最好的基因："+b);
System.out.println();
System.out.println("需氧量："+Environment.need_oxy_all[bestGene[0]]);
System.out.println("湿度要求："+Environment.need_moi_all[bestGene[1]]);
System.out.println("食物需求："+Environment.need_food_all[bestGene[2]]);
System.out.println("温度需求："+Environment.need_tem_first_all[bestGene[3]]+"-"+Environment.need_tem_second_all[bestGene[3]]);
System.out.println("速度："+bestGene[4]);
System.out.println("耐力："+bestGene[5]);
System.out.println();
double z = Best.getFitness();
System.out.println("流程结束");
EndFenestra aallah = new EndFenestra("流程结束",z,b); //结束
break;
}
else{
lastBestFitness = Best.getFitness();
generationNumber++;
System.out.println("第"+generationNumber+"代结束————————————\n");
EndFenestra aawllsah = new EndFenestra("流程进行中","一代结束");
}
//处♂刑所有弱子个体
for(int i = Population.setOfIndividual.capacity()/2 -1; i< Population.setOfIndividual.size(); )
Population.setOfIndividual.remove(0);
//繁殖
int reproduceSize = Population.setOfIndividual.size();
while(Population.setOfIndividual.size() < Population.setOfIndividual.capacity() && reproduceSize!=0){
for(int i = 0;i<reproduceSize-1;i+=2){
Population.setOfIndividual.add(Event.reproduce((Individual) Population.setOfIndividual.get(i),(Individual) Population.setOfIndividual.get(i+1)));
}
reproduceSize /= 2 ;
if(reproduceSize <= 1)//解决剩下1个个体无法繁殖的问题
Population.setOfIndividual.add(Event.reproduce((Individual) Population.setOfIndividual.get(Population.setOfIndividual.size()-1),(Individual) Population.setOfIndividual.get(Population.setOfIndividual.size()-2)));
}
}
}
}
| true |
24913_10 |
public class SkillFactory {
public static Skill createSkill(int type, Character target1, Character target2, Creature target3) {
/*
target1 target2 target3 三个目标来供修改
若不需要则传入null
*/
switch (type) {
//下方开始是唤魔
/*
鲜血榨汁机 唤魔 械宗 （25/0/3/0） 每个中回合结束时对自己的人物造成三点伤害，并获得50点能量
*/
case 0: return new ChangeCurrentHP(new ChangePower(new BasicSkill(0, target1), 50), -3);
/*
奇怪的祭坛 唤魔 神宗 （75/0/3/0） 在己方回合每牺牲一个友方随从，便获得50点能量（最多牺牲五个）
*/
case 1: return new ChangePower(new BasicSkill(0, target1), 50);
/*
邪能收集台 唤魔 法宗 （25/0/5/0）每个中回合结束时，获得25点能量
*/
case 2: return new ChangePower(new BasicSkill(0, target1), 25);
/*
淘气的小鬼 唤魔 械宗 （25/2/1/2） 战吼：指定一个友方所从，对其造成两点伤害
*/
case 3: return new ChangeHP(new BasicSkill(0, target1), -2);
/*
嗜血者 唤魔 神宗 （200/5/5/2-3） 战吼：对所有角色造成一点伤害，每有一个角色死亡则获得攻击力加一血加一
*/
case 4: return new ChangeHP(new ChangeATK(new BasicSkill(0, target1), 1), 1);
/*
被诅咒的封印 唤魔 神宗（500/0/25/0）在回合结束时若己方人物血量正好等于五点，则杀死友方人物，将其替代为造物者
*/
//case 5: return new ;
/*
地狱之门 唤魔 法宗 （300/0/0/0）战吼：以自己为中心3x3的范围内，对所有角色造成三点伤害
*/
case 6: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
替死冤魂 唤魔 法宗 （300/4/10/2-3）战吼：选择一个友方yw，若该yw在敌方回合死亡，则使替死幽魂死亡，友方yw复原原来血量的一半（四舍五入）
*/
case 7: return new ChangeHP(new BasicSkill(0, target1), ((yw) target1).get("HP") / 2);
/*
吞噬者的巢穴 唤魔 法宗（350/0/0/0） 战吼：在友方军团3x3的范围内，选择一个战场上的格子，将吞噬者的巢穴放在上面（用不可视），
若有地方军团走到上面，则会召唤系统人物吞噬者，20血，自带5点攻击，且军团里有两只（25/3/2/2）的yw，每个中回合放一只（25/3/2/2）的yw，
并选择攻击最近的人物
*/
case 8: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
梦魇巨怪 唤魔 神宗（175/7/12/2-3）每个中回合结束时，对自己造成4点伤害
*/
case 9: return new ChangeHP(new BasicSkill(0, target1), -4);
/*
凋谢的恶魔之花 唤魔 械宗（125/5/5/2-3）亡语:使所有友方角色恢复六点血
*/
case 10: return new ChangeHP(new BasicSkill(0, target1), 6);
/*
被折磨的弃教者 唤魔 械宗（100/2/10/2-3）该随从每受到一次伤害，就随机对一个非友方角色造成两点伤害
*/
case 11: return new ChangeHP(new BasicSkill(0, target1), -2);
//下方开始是潜行
/*
被诅咒的封印 潜行 神宗（500/0/25/0）在回合开始时，己方军团格子上有两只需消耗500能量以上的一模一样的yw（能量/攻击/血/攻击距离），
*/
//case 12: return new ;
/*
禁忌的瞳术 潜行 神宗 （200/0/25/0）将你的第二技能换为消耗25点的一段瞳术，以自己为起点选择一排或是一列在这个中回合中可视所有这些格子上的内容。
若在己方回合杀死两个己方随从，则升级为消耗25点的二段瞳术，可视所有以自己为中心3x3范围内所有格子。若在己方回合再杀死两个己方随从，则升级为消耗
25点的三段瞳术，可视所有格子
*/
//case 13: return new ;
/*
傀儡·爱 潜行 械宗（125/3/10/2-5）战吼：若傀儡恨在场上，则使一个有方角色恢复5点血
*/
case 14: return new ChangeHP(new BasicSkill(0, target1), 5);
/*
傀儡·恨 潜行 械宗（125/10/3/2-3）己方中回合结束时。若傀儡·爱在场上，则对其两边的yw分别造成三点伤害
*/
case 15: return new ChangeHP(new BasicSkill(0, target1), -3);
/*
傀儡·情 潜行 械宗（225/？/？/1-5）若傀儡·爱在场上，获得5攻击力，10血；若傀儡恨在场上则获得10攻，5血；若都没有，则获得6攻6血
*/
//case 16: return new ;
/*
迷雾释放者 潜行 法宗 （175/0/0/0）战吼：在以己为中心3x3的范围内，放置在战场上，成为一个角色，拥有十点血（不能移动），战场重新布回新的战争
迷雾，且迷雾只使所走过的最后三个格子可视。
*/
case 17: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
暗影织布机 潜行 神宗 （175/0/0/0）战吼：在以己为中心3x3的范围内，放置成为一个角色，拥有十点血（不能移动），每个中回合结束时获得150点能量
*/
case 18: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
尖锐的匕首 潜行 械宗（250/0/9/0）己方角色本中回合获得五点攻击，攻击距离为2-4
*/
case 19: return new ChangeATK(new ChangeRange(new BasicSkill(0, target1), 2), 5);
/*
小型青玉石 潜行 神宗 （25/0/4/0） 每个中回合开始时，获得50点能量
*/
case 20: return new ChangePower(new BasicSkill(0, target1), 50);
/*
飞刀陷阱 潜行 法宗（300/0/0/0）战吼：放置一个脚踏板拥有十五点血（不能移动），在同一排或同一列放置一个飞刀发射器拥有十五点血（不能移动），
若有人踩在脚踏板上，则发射器射中当在他路径上的第一个军团，整个军团的所有角色扣五滴血
*/
case 21: return new CreateCreature(new BasicSkill(0, null), target3);
/*
闪避术（停滞五回合） 潜行 法宗 （150/0/0/0）战吼： 在下个己方回合开始前，免疫三次对方的攻击（每攻击到一个yw或己方人物算一次）
被诅咒的封印 唤魔 神宗（500/0/25/0）在回合结束时若己方人物血量正好等于五点，则杀死友方人物，将其替代为造物者
*/
//case 22: return new;
/*
残影制造术（停滞五回合） 潜行 法宗 （150/0/0/0）战吼：在现在的格子上制造残影，若残影被视可视到，仍会显示释放时的所有信息，
在对方第一次攻击完时，则会消失
*/
//case 23:;
//下方开始是undefined
/*
FailTrial1 (25/0/3/0)每个中回合结束时，获得25点能量
*/
case 24: return new ChangePower(new BasicSkill(0,target1),25);
/*
FailTrial2 (50/0/3/0)每个中回合开始时，获得50点能量
*/
case 25: return new ChangePower(new BasicSkill(0,target1),50);
/*
FailTrial8 (100/2/3/2)每个中回合结束时，人物恢复3点血
*/
case 26: return new ChangeHP(new BasicSkill(0,target1),3);
/*
1.FailTrial9 (100/5/6/2-3)每个中回合结束时，人物扣2点血
*/
case 27: return new ChangeHP(new BasicSkill(0,target1),-2);
/*
FailTrial10 (500/0/0/0)消灭一个yw
*/
case 28: return new BasicSkill(0,target1);
/*
种族别名：Undefined
种族技能：人物攻击（耗费能量25）：人物获得2点攻击和2-3点攻击距离
*/
case 29: return new ChangeATK(new ChangeRange(new BasicSkill(25,target1),2),2);
/*
种族别名：Undefined
第二技能：人物回血（耗费能量25）：回两点血
*/
case 30: return new ChangeHP(new BasicSkill(25,target1),2);
}
return null;
}
} | Luke-lujunxian/YW-s-legend-sever | YWLegend/src/SkillFactory.java | 2,940 | /*
替死冤魂 唤魔 法宗 （300/4/10/2-3）战吼：选择一个友方yw，若该yw在敌方回合死亡，则使替死幽魂死亡，友方yw复原原来血量的一半（四舍五入）
*/ | block_comment | zh-cn |
public class SkillFactory {
public static Skill createSkill(int type, Character target1, Character target2, Creature target3) {
/*
target1 target2 target3 三个目标来供修改
若不需要则传入null
*/
switch (type) {
//下方开始是唤魔
/*
鲜血榨汁机 唤魔 械宗 （25/0/3/0） 每个中回合结束时对自己的人物造成三点伤害，并获得50点能量
*/
case 0: return new ChangeCurrentHP(new ChangePower(new BasicSkill(0, target1), 50), -3);
/*
奇怪的祭坛 唤魔 神宗 （75/0/3/0） 在己方回合每牺牲一个友方随从，便获得50点能量（最多牺牲五个）
*/
case 1: return new ChangePower(new BasicSkill(0, target1), 50);
/*
邪能收集台 唤魔 法宗 （25/0/5/0）每个中回合结束时，获得25点能量
*/
case 2: return new ChangePower(new BasicSkill(0, target1), 25);
/*
淘气的小鬼 唤魔 械宗 （25/2/1/2） 战吼：指定一个友方所从，对其造成两点伤害
*/
case 3: return new ChangeHP(new BasicSkill(0, target1), -2);
/*
嗜血者 唤魔 神宗 （200/5/5/2-3） 战吼：对所有角色造成一点伤害，每有一个角色死亡则获得攻击力加一血加一
*/
case 4: return new ChangeHP(new ChangeATK(new BasicSkill(0, target1), 1), 1);
/*
被诅咒的封印 唤魔 神宗（500/0/25/0）在回合结束时若己方人物血量正好等于五点，则杀死友方人物，将其替代为造物者
*/
//case 5: return new ;
/*
地狱之门 唤魔 法宗 （300/0/0/0）战吼：以自己为中心3x3的范围内，对所有角色造成三点伤害
*/
case 6: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
替死冤 <SUF>*/
case 7: return new ChangeHP(new BasicSkill(0, target1), ((yw) target1).get("HP") / 2);
/*
吞噬者的巢穴 唤魔 法宗（350/0/0/0） 战吼：在友方军团3x3的范围内，选择一个战场上的格子，将吞噬者的巢穴放在上面（用不可视），
若有地方军团走到上面，则会召唤系统人物吞噬者，20血，自带5点攻击，且军团里有两只（25/3/2/2）的yw，每个中回合放一只（25/3/2/2）的yw，
并选择攻击最近的人物
*/
case 8: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
梦魇巨怪 唤魔 神宗（175/7/12/2-3）每个中回合结束时，对自己造成4点伤害
*/
case 9: return new ChangeHP(new BasicSkill(0, target1), -4);
/*
凋谢的恶魔之花 唤魔 械宗（125/5/5/2-3）亡语:使所有友方角色恢复六点血
*/
case 10: return new ChangeHP(new BasicSkill(0, target1), 6);
/*
被折磨的弃教者 唤魔 械宗（100/2/10/2-3）该随从每受到一次伤害，就随机对一个非友方角色造成两点伤害
*/
case 11: return new ChangeHP(new BasicSkill(0, target1), -2);
//下方开始是潜行
/*
被诅咒的封印 潜行 神宗（500/0/25/0）在回合开始时，己方军团格子上有两只需消耗500能量以上的一模一样的yw（能量/攻击/血/攻击距离），
*/
//case 12: return new ;
/*
禁忌的瞳术 潜行 神宗 （200/0/25/0）将你的第二技能换为消耗25点的一段瞳术，以自己为起点选择一排或是一列在这个中回合中可视所有这些格子上的内容。
若在己方回合杀死两个己方随从，则升级为消耗25点的二段瞳术，可视所有以自己为中心3x3范围内所有格子。若在己方回合再杀死两个己方随从，则升级为消耗
25点的三段瞳术，可视所有格子
*/
//case 13: return new ;
/*
傀儡·爱 潜行 械宗（125/3/10/2-5）战吼：若傀儡恨在场上，则使一个有方角色恢复5点血
*/
case 14: return new ChangeHP(new BasicSkill(0, target1), 5);
/*
傀儡·恨 潜行 械宗（125/10/3/2-3）己方中回合结束时。若傀儡·爱在场上，则对其两边的yw分别造成三点伤害
*/
case 15: return new ChangeHP(new BasicSkill(0, target1), -3);
/*
傀儡·情 潜行 械宗（225/？/？/1-5）若傀儡·爱在场上，获得5攻击力，10血；若傀儡恨在场上则获得10攻，5血；若都没有，则获得6攻6血
*/
//case 16: return new ;
/*
迷雾释放者 潜行 法宗 （175/0/0/0）战吼：在以己为中心3x3的范围内，放置在战场上，成为一个角色，拥有十点血（不能移动），战场重新布回新的战争
迷雾，且迷雾只使所走过的最后三个格子可视。
*/
case 17: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
暗影织布机 潜行 神宗 （175/0/0/0）战吼：在以己为中心3x3的范围内，放置成为一个角色，拥有十点血（不能移动），每个中回合结束时获得150点能量
*/
case 18: return new CreateCreature(new BasicSkill(0, target1), target3);
/*
尖锐的匕首 潜行 械宗（250/0/9/0）己方角色本中回合获得五点攻击，攻击距离为2-4
*/
case 19: return new ChangeATK(new ChangeRange(new BasicSkill(0, target1), 2), 5);
/*
小型青玉石 潜行 神宗 （25/0/4/0） 每个中回合开始时，获得50点能量
*/
case 20: return new ChangePower(new BasicSkill(0, target1), 50);
/*
飞刀陷阱 潜行 法宗（300/0/0/0）战吼：放置一个脚踏板拥有十五点血（不能移动），在同一排或同一列放置一个飞刀发射器拥有十五点血（不能移动），
若有人踩在脚踏板上，则发射器射中当在他路径上的第一个军团，整个军团的所有角色扣五滴血
*/
case 21: return new CreateCreature(new BasicSkill(0, null), target3);
/*
闪避术（停滞五回合） 潜行 法宗 （150/0/0/0）战吼： 在下个己方回合开始前，免疫三次对方的攻击（每攻击到一个yw或己方人物算一次）
被诅咒的封印 唤魔 神宗（500/0/25/0）在回合结束时若己方人物血量正好等于五点，则杀死友方人物，将其替代为造物者
*/
//case 22: return new;
/*
残影制造术（停滞五回合） 潜行 法宗 （150/0/0/0）战吼：在现在的格子上制造残影，若残影被视可视到，仍会显示释放时的所有信息，
在对方第一次攻击完时，则会消失
*/
//case 23:;
//下方开始是undefined
/*
FailTrial1 (25/0/3/0)每个中回合结束时，获得25点能量
*/
case 24: return new ChangePower(new BasicSkill(0,target1),25);
/*
FailTrial2 (50/0/3/0)每个中回合开始时，获得50点能量
*/
case 25: return new ChangePower(new BasicSkill(0,target1),50);
/*
FailTrial8 (100/2/3/2)每个中回合结束时，人物恢复3点血
*/
case 26: return new ChangeHP(new BasicSkill(0,target1),3);
/*
1.FailTrial9 (100/5/6/2-3)每个中回合结束时，人物扣2点血
*/
case 27: return new ChangeHP(new BasicSkill(0,target1),-2);
/*
FailTrial10 (500/0/0/0)消灭一个yw
*/
case 28: return new BasicSkill(0,target1);
/*
种族别名：Undefined
种族技能：人物攻击（耗费能量25）：人物获得2点攻击和2-3点攻击距离
*/
case 29: return new ChangeATK(new ChangeRange(new BasicSkill(25,target1),2),2);
/*
种族别名：Undefined
第二技能：人物回血（耗费能量25）：回两点血
*/
case 30: return new ChangeHP(new BasicSkill(25,target1),2);
}
return null;
}
} | false |
53859_36 | package com.hao.udv;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Toast;
import com.hao.gamefivechess.R;
/**
* Created by ZhangHao on 2017/6/27.
* 五子棋 View
*/
public class FiveChessView extends View implements View.OnTouchListener {
//画笔
private Paint paint;
//棋子数组
private int[][] chessArray;
//当前下棋顺序(默认白棋先下)
private boolean isWhite = true;
//游戏是否结束
private boolean isGameOver = false;
//bitmap
private Bitmap whiteChess;
private Bitmap blackChess;
//Rect
private Rect rect;
//棋盘宽高
private float len;
//棋盘格数
private int GRID_NUMBER = 15;
//每格之间的距离
private float preWidth;
//边距
private float offset;
//回调
private GameCallBack callBack;
//当前黑白棋胜利次数
private int whiteChessCount, blackChessCount;
//是否是玩家的回合
private boolean isUserBout = true;
//玩家执子颜色
private int userChess = WHITE_CHESS;
//玩家/AI胜利次数
private int userScore = 0, aiScore = 0;
/**
* 一些常量
*/
//白棋
public static final int WHITE_CHESS = 1;
//黑棋
public static final int BLACK_CHESS = 2;
//无棋
public static final int NO_CHESS = 0;
//白棋赢
public static final int WHITE_WIN = 101;
//黑棋赢
public static final int BLACK_WIN = 102;
//平局
public static final int NO_WIN = 103;
public FiveChessView(Context context) {
this(context, null);
}
public FiveChessView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public FiveChessView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
//初始化Paint
paint = new Paint();
//设置抗锯齿
paint.setAntiAlias(true);
paint.setColor(Color.BLACK);
//初始化chessArray
chessArray = new int[GRID_NUMBER][GRID_NUMBER];
//初始化棋子图片bitmap
whiteChess = BitmapFactory.decodeResource(context.getResources(), R.drawable.white_chess);
blackChess = BitmapFactory.decodeResource(context.getResources(), R.drawable.black_chess);
//初始化胜利局数
whiteChessCount = 0;
blackChessCount = 0;
//初始化Rect
rect = new Rect();
//设置点击监听
setOnTouchListener(this);
//重置棋盘状态
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
chessArray[i][j] = 0;
}
}
}
/**
* 重新测量宽高，确保宽高一样
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//获取高宽值
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
//获取宽高中较小的值
int len = width > height ? height : width;
//重新设置宽高
setMeasuredDimension(len, len);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
//棋盘为一个GRID_NUMBER*GRID_NUMBER的正方形，所有棋盘宽高必须一样
len = getWidth() > getHeight() ? getHeight() : getWidth();
preWidth = len / GRID_NUMBER;
//边距
offset = preWidth / 2;
//棋盘线条
for (int i = 0; i < GRID_NUMBER; i++) {
float start = i * preWidth + offset;
//横线
canvas.drawLine(offset, start, len - offset, start, paint);
//竖线
canvas.drawLine(start, offset, start, len - offset, paint);
}
//绘制棋子
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
//rect中点坐标
float rectX = offset + i * preWidth;
float rectY = offset + j * preWidth;
//设置rect位置
rect.set((int) (rectX - offset), (int) (rectY - offset),
(int) (rectX + offset), (int) (rectY + offset));
//遍历chessArray
switch (chessArray[i][j]) {
case WHITE_CHESS:
//绘制白棋
canvas.drawBitmap(whiteChess, null, rect, paint);
break;
case BLACK_CHESS:
//绘制黑棋
canvas.drawBitmap(blackChess, null, rect, paint);
break;
}
}
}
}
/**
* 判断是否结束
*/
private void checkGameOver() {
//获取落子的颜色(如果当前是白棋，则落子是黑棋)
int chess = isWhite ? BLACK_CHESS : WHITE_CHESS;
//棋盘是否填满
boolean isFull = true;
//遍历chessArray
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
//判断棋盘是否填满
if (chessArray[i][j] != BLACK_CHESS && chessArray[i][j] != WHITE_CHESS) {
isFull = false;
}
//只需要判断落子是否五连即可
if (chessArray[i][j] == chess) {
//判断五子相连
if (isFiveSame(i, j)) {
//五子相连游戏结束
isGameOver = true;
if (callBack != null) {
//判断黑白棋胜利
if (chess == WHITE_CHESS) {
whiteChessCount++;
} else {
blackChessCount++;
}
//判断玩家/AI 胜利
if (userChess == chess) {
userScore++;
} else {
aiScore++;
}
callBack.GameOver(chess == WHITE_CHESS ? WHITE_WIN : BLACK_WIN);
}
return;
}
}
}
}
//如果棋盘填满，平局结束
if (isFull) {
isGameOver = true;
if (callBack != null) {
callBack.GameOver(NO_WIN);
}
}
}
/**
* 重置游戏
*/
public void resetGame() {
isGameOver = false;
//重置棋盘状态
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
chessArray[i][j] = 0;
}
}
//更新UI
postInvalidate();
}
/**
* 判断是否存在五子相连
*
* @return
*/
private boolean isFiveSame(int x, int y) {
//判断横向
if (x + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x + 1][y] && chessArray[x][y] == chessArray[x + 2][y]
&& chessArray[x][y] == chessArray[x + 3][y] && chessArray[x][y] == chessArray[x + 4][y]) {
return true;
}
}
//判断纵向
if (y + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x][y + 1] && chessArray[x][y] == chessArray[x][y + 2]
&& chessArray[x][y] == chessArray[x][y + 3] && chessArray[x][y] == chessArray[x][y + 4]) {
return true;
}
}
//判断斜向(左上到右下)
if (y + 4 < GRID_NUMBER && x + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x + 1][y + 1] && chessArray[x][y] == chessArray[x + 2][y + 2]
&& chessArray[x][y] == chessArray[x + 3][y + 3] && chessArray[x][y] == chessArray[x + 4][y + 4]) {
return true;
}
}
//判断斜向(左下到右上)
if (y - 4 > 0 && x + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x + 1][y - 1] && chessArray[x][y] == chessArray[x + 2][y - 2]
&& chessArray[x][y] == chessArray[x + 3][y - 3] && chessArray[x][y] == chessArray[x + 4][y - 4]) {
return true;
}
}
return false;
}
//电脑判断游戏结束
public void checkAiGameOver() {
isWhite = userChess == WHITE_CHESS;
checkGameOver();
}
@Override
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
if (!isGameOver && isUserBout) {
//获取按下时的位置
float downX = event.getX();
float downY = event.getY();
//点击的位置在棋盘上
if (downX >= offset / 2 && downX <= len - offset / 2
&& downY >= offset / 2 && downY <= len - offset / 2) {
//获取棋子对应的位置
int x = (int) (downX / preWidth);
int y = (int) (downY / preWidth);
//判断当前位置是否已经有子
if (chessArray[x][y] != WHITE_CHESS &&
chessArray[x][y] != BLACK_CHESS) {
//给数组赋值
chessArray[x][y] = userChess;
//修改当前落子颜色
isWhite = userChess == WHITE_CHESS;
//修改当前为电脑执子
isUserBout = false;
//更新棋盘
postInvalidate();
//判断是否结束
checkGameOver();
//回调当前执子
if (callBack != null) {
callBack.ChangeGamer(isWhite);
}
}
}
} else if (isGameOver) {
Toast.makeText(getContext(), "游戏已经结束，请重新开始！",
Toast.LENGTH_SHORT).show();
}
break;
}
return false;
}
public void setCallBack(GameCallBack callBack) {
this.callBack = callBack;
}
public int getWhiteChessCount() {
return whiteChessCount;
}
public int getBlackChessCount() {
return blackChessCount;
}
public int[][] getChessArray() {
return chessArray;
}
public void setUserBout(boolean userBout) {
isUserBout = userBout;
}
public void setUserChess(int userChess) {
this.userChess = userChess;
}
public int getUserScore() {
return userScore;
}
public int getAiScore() {
return aiScore;
}
}
| LuoChen-Hao/GameFiveChess | app/src/main/java/com/hao/udv/FiveChessView.java | 2,949 | /**
* 判断是否结束
*/ | block_comment | zh-cn | package com.hao.udv;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.Toast;
import com.hao.gamefivechess.R;
/**
* Created by ZhangHao on 2017/6/27.
* 五子棋 View
*/
public class FiveChessView extends View implements View.OnTouchListener {
//画笔
private Paint paint;
//棋子数组
private int[][] chessArray;
//当前下棋顺序(默认白棋先下)
private boolean isWhite = true;
//游戏是否结束
private boolean isGameOver = false;
//bitmap
private Bitmap whiteChess;
private Bitmap blackChess;
//Rect
private Rect rect;
//棋盘宽高
private float len;
//棋盘格数
private int GRID_NUMBER = 15;
//每格之间的距离
private float preWidth;
//边距
private float offset;
//回调
private GameCallBack callBack;
//当前黑白棋胜利次数
private int whiteChessCount, blackChessCount;
//是否是玩家的回合
private boolean isUserBout = true;
//玩家执子颜色
private int userChess = WHITE_CHESS;
//玩家/AI胜利次数
private int userScore = 0, aiScore = 0;
/**
* 一些常量
*/
//白棋
public static final int WHITE_CHESS = 1;
//黑棋
public static final int BLACK_CHESS = 2;
//无棋
public static final int NO_CHESS = 0;
//白棋赢
public static final int WHITE_WIN = 101;
//黑棋赢
public static final int BLACK_WIN = 102;
//平局
public static final int NO_WIN = 103;
public FiveChessView(Context context) {
this(context, null);
}
public FiveChessView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public FiveChessView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
//初始化Paint
paint = new Paint();
//设置抗锯齿
paint.setAntiAlias(true);
paint.setColor(Color.BLACK);
//初始化chessArray
chessArray = new int[GRID_NUMBER][GRID_NUMBER];
//初始化棋子图片bitmap
whiteChess = BitmapFactory.decodeResource(context.getResources(), R.drawable.white_chess);
blackChess = BitmapFactory.decodeResource(context.getResources(), R.drawable.black_chess);
//初始化胜利局数
whiteChessCount = 0;
blackChessCount = 0;
//初始化Rect
rect = new Rect();
//设置点击监听
setOnTouchListener(this);
//重置棋盘状态
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
chessArray[i][j] = 0;
}
}
}
/**
* 重新测量宽高，确保宽高一样
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//获取高宽值
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
//获取宽高中较小的值
int len = width > height ? height : width;
//重新设置宽高
setMeasuredDimension(len, len);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
//棋盘为一个GRID_NUMBER*GRID_NUMBER的正方形，所有棋盘宽高必须一样
len = getWidth() > getHeight() ? getHeight() : getWidth();
preWidth = len / GRID_NUMBER;
//边距
offset = preWidth / 2;
//棋盘线条
for (int i = 0; i < GRID_NUMBER; i++) {
float start = i * preWidth + offset;
//横线
canvas.drawLine(offset, start, len - offset, start, paint);
//竖线
canvas.drawLine(start, offset, start, len - offset, paint);
}
//绘制棋子
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
//rect中点坐标
float rectX = offset + i * preWidth;
float rectY = offset + j * preWidth;
//设置rect位置
rect.set((int) (rectX - offset), (int) (rectY - offset),
(int) (rectX + offset), (int) (rectY + offset));
//遍历chessArray
switch (chessArray[i][j]) {
case WHITE_CHESS:
//绘制白棋
canvas.drawBitmap(whiteChess, null, rect, paint);
break;
case BLACK_CHESS:
//绘制黑棋
canvas.drawBitmap(blackChess, null, rect, paint);
break;
}
}
}
}
/**
* 判断是 <SUF>*/
private void checkGameOver() {
//获取落子的颜色(如果当前是白棋，则落子是黑棋)
int chess = isWhite ? BLACK_CHESS : WHITE_CHESS;
//棋盘是否填满
boolean isFull = true;
//遍历chessArray
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
//判断棋盘是否填满
if (chessArray[i][j] != BLACK_CHESS && chessArray[i][j] != WHITE_CHESS) {
isFull = false;
}
//只需要判断落子是否五连即可
if (chessArray[i][j] == chess) {
//判断五子相连
if (isFiveSame(i, j)) {
//五子相连游戏结束
isGameOver = true;
if (callBack != null) {
//判断黑白棋胜利
if (chess == WHITE_CHESS) {
whiteChessCount++;
} else {
blackChessCount++;
}
//判断玩家/AI 胜利
if (userChess == chess) {
userScore++;
} else {
aiScore++;
}
callBack.GameOver(chess == WHITE_CHESS ? WHITE_WIN : BLACK_WIN);
}
return;
}
}
}
}
//如果棋盘填满，平局结束
if (isFull) {
isGameOver = true;
if (callBack != null) {
callBack.GameOver(NO_WIN);
}
}
}
/**
* 重置游戏
*/
public void resetGame() {
isGameOver = false;
//重置棋盘状态
for (int i = 0; i < GRID_NUMBER; i++) {
for (int j = 0; j < GRID_NUMBER; j++) {
chessArray[i][j] = 0;
}
}
//更新UI
postInvalidate();
}
/**
* 判断是否存在五子相连
*
* @return
*/
private boolean isFiveSame(int x, int y) {
//判断横向
if (x + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x + 1][y] && chessArray[x][y] == chessArray[x + 2][y]
&& chessArray[x][y] == chessArray[x + 3][y] && chessArray[x][y] == chessArray[x + 4][y]) {
return true;
}
}
//判断纵向
if (y + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x][y + 1] && chessArray[x][y] == chessArray[x][y + 2]
&& chessArray[x][y] == chessArray[x][y + 3] && chessArray[x][y] == chessArray[x][y + 4]) {
return true;
}
}
//判断斜向(左上到右下)
if (y + 4 < GRID_NUMBER && x + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x + 1][y + 1] && chessArray[x][y] == chessArray[x + 2][y + 2]
&& chessArray[x][y] == chessArray[x + 3][y + 3] && chessArray[x][y] == chessArray[x + 4][y + 4]) {
return true;
}
}
//判断斜向(左下到右上)
if (y - 4 > 0 && x + 4 < GRID_NUMBER) {
if (chessArray[x][y] == chessArray[x + 1][y - 1] && chessArray[x][y] == chessArray[x + 2][y - 2]
&& chessArray[x][y] == chessArray[x + 3][y - 3] && chessArray[x][y] == chessArray[x + 4][y - 4]) {
return true;
}
}
return false;
}
//电脑判断游戏结束
public void checkAiGameOver() {
isWhite = userChess == WHITE_CHESS;
checkGameOver();
}
@Override
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
if (!isGameOver && isUserBout) {
//获取按下时的位置
float downX = event.getX();
float downY = event.getY();
//点击的位置在棋盘上
if (downX >= offset / 2 && downX <= len - offset / 2
&& downY >= offset / 2 && downY <= len - offset / 2) {
//获取棋子对应的位置
int x = (int) (downX / preWidth);
int y = (int) (downY / preWidth);
//判断当前位置是否已经有子
if (chessArray[x][y] != WHITE_CHESS &&
chessArray[x][y] != BLACK_CHESS) {
//给数组赋值
chessArray[x][y] = userChess;
//修改当前落子颜色
isWhite = userChess == WHITE_CHESS;
//修改当前为电脑执子
isUserBout = false;
//更新棋盘
postInvalidate();
//判断是否结束
checkGameOver();
//回调当前执子
if (callBack != null) {
callBack.ChangeGamer(isWhite);
}
}
}
} else if (isGameOver) {
Toast.makeText(getContext(), "游戏已经结束，请重新开始！",
Toast.LENGTH_SHORT).show();
}
break;
}
return false;
}
public void setCallBack(GameCallBack callBack) {
this.callBack = callBack;
}
public int getWhiteChessCount() {
return whiteChessCount;
}
public int getBlackChessCount() {
return blackChessCount;
}
public int[][] getChessArray() {
return chessArray;
}
public void setUserBout(boolean userBout) {
isUserBout = userBout;
}
public void setUserChess(int userChess) {
this.userChess = userChess;
}
public int getUserScore() {
return userScore;
}
public int getAiScore() {
return aiScore;
}
}
| false |
45532_8 | package com.dong.dongweather.gson;
import com.google.gson.annotations.SerializedName;
/**
* Created by Administrator on 2017/4/18.
*/
public class Now {
//天气状况
@SerializedName("cond")
public WeatherRegime weatherRegime;
public class WeatherRegime {
public String code;
public String txt;
}
//体感温度
public String fl;
//相对湿度
public String hum;
//降水量
@SerializedName("pcpn")
public String mypcpn;
//气压
public String pres;
//温度
public String tmp;
//能见度
public String vis;
public Wind wind;
public class Wind {
//风向（360）度
public String deg;
//风向，八个大方向（西北风）
public String dir;
//风力等级
public String sc;
//风速
public String spd;
}
//
// "now": { //实况天气
// "cond": { //天气状况
// "code": "104", //天气状况代码
// "txt": "阴" //天气状况描述
// },
// "fl": "11", //体感温度
// "hum": "31", //相对湿度（%）
// "pcpn": "0", //降水量（mm）
// "pres": "1025", //气压
// "tmp": "13", //温度
// "vis": "10", //能见度（km）
// "wind": { //风力风向
// "deg": "40", //风向（360度）
// "dir": "东北风", //风向
// "sc": "4-5", //风力
// "spd": "24" //风速（kmph）
// }
// },
}
| LuoPeiQin/DongWeather | app/src/main/java/com/dong/dongweather/gson/Now.java | 493 | //风力等级 | line_comment | zh-cn | package com.dong.dongweather.gson;
import com.google.gson.annotations.SerializedName;
/**
* Created by Administrator on 2017/4/18.
*/
public class Now {
//天气状况
@SerializedName("cond")
public WeatherRegime weatherRegime;
public class WeatherRegime {
public String code;
public String txt;
}
//体感温度
public String fl;
//相对湿度
public String hum;
//降水量
@SerializedName("pcpn")
public String mypcpn;
//气压
public String pres;
//温度
public String tmp;
//能见度
public String vis;
public Wind wind;
public class Wind {
//风向（360）度
public String deg;
//风向，八个大方向（西北风）
public String dir;
//风力 <SUF>
public String sc;
//风速
public String spd;
}
//
// "now": { //实况天气
// "cond": { //天气状况
// "code": "104", //天气状况代码
// "txt": "阴" //天气状况描述
// },
// "fl": "11", //体感温度
// "hum": "31", //相对湿度（%）
// "pcpn": "0", //降水量（mm）
// "pres": "1025", //气压
// "tmp": "13", //温度
// "vis": "10", //能见度（km）
// "wind": { //风力风向
// "deg": "40", //风向（360度）
// "dir": "东北风", //风向
// "sc": "4-5", //风力
// "spd": "24" //风速（kmph）
// }
// },
}
| false |
40459_1 | package com.ys.yoosir.zzshow.mvp.model.entity.netease;
import java.util.List;
/**
* 新闻详情
* @version 1.0
* Created by Yoosir on 2016/11/15 0015.
*/
public class NewsDetail {
/**
*
*"body": "<p> 5300万欧元，约为4.5亿人民币。对于绝大多数人而言，这是一生都不可能积累到的财富。但在过去的一年中，梅西为西班牙税务部门缴纳的税款总额，竟然高达5300万欧元！毫无疑问，梅西已经成了西班牙的“顶级纳税人”。</p><!--IMG#0--><p> 据《世界体育报》报道，梅西上缴的这5300万欧元税款，分为两个部分。一部分是过去一年间他所应缴纳的常规税款，这包括他的个人所得税、财产税以及肖像权收入所产生的税款。另一部分，则与他的偷税纳税事件有关。在2007到2009年，梅西被证实的确偷税纳税。在此事被调查后，梅西立刻组织财务团队自行查账，并补缴了2010年到2012年这三年间所偷漏的税款。</p><p> 梅西在这一年内的缴税金额，很可能还将继续增加。由于偷税漏税事件，梅西很可能会在近期被迫向税务部门缴纳一笔300万欧元的罚款。这也就意味着，梅西在一年内的缴税总金额将极有可能达到5600万欧元。而在过去7年中，梅西向西班牙税务部门缴纳的税款总额已经超过了1亿欧元。</p><!--IMG#1--><p> 在世界杯淘汰赛中，梅西没有进球，阿根廷也最终输给德国名列亚军。就连阿根廷传奇肯佩斯都不满梅西，他批评梅西在淘汰赛中隐身。针对外界对梅西的批评，阿根廷精神领袖马斯切拉诺为跳蚤出头。在小马哥看来，梅西挨批是一件非常不公平的事情。</p><p> “对梅西的批评令人心痛，这不公平。没有梅西的话，我们根本不可能打进世界杯决赛。”马斯切拉诺表态，“萨维利亚？三年来他展现了能力和真诚，我希望他能留下，因为我相信我们已经证明了自己的实力。”</p>",
*"users": [],
*"ydbaike": [],
*"replyCount": 5586,
*"link": [],
*"img": [],
*"votes": [],
*"shareLink": "http://c.m.163.com/news/a/A1E29FK800051C8V.html?spss=newsapp&spsw=1",
*"digest": "",
*"topiclist_news": [],
*"dkeys": "梅西",
*"topiclist": [],
*"docid": "A1E29FK800051C8V",
*"picnews": true,
*"title": "梅西一年内缴税达5300万欧元",
*"tid": "",
*"template": "normal1",
*"threadVote": 1,
*"threadAgainst": 5,
*"boboList": [],
*"replyBoard": "sports2_bbs",
*"huati": [],
*"source": "网易体育",
*"hasNext": false,
*"voicecomment": "off",
*"relative_sys": [],
* "ptime": "2014-07-18 08:28:15"
*/
private String body;
private List<?> users;
private List<?> ydbaike;
private int replyCount;
private List<?> link;
private List<ImgBean> img;
private List<?> votes;
private String shareLink;
private String digest;
private List<?> topiclist_news;
private String dkeys;
private List<?> topiclist;
private String docid;
private boolean picnews;
private String title;
private String tid;
private String template;
private int threadVote;
private int threadAgainst;
private List<?> boboList;
private String replyBoard;
private List<HuatiBean> huati;
private String source;
private boolean hasNext;
private String voicecomment;
private List<RelativeSysBean> relative_sys;
private String ptime;
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public List<?> getUsers() {
return users;
}
public void setUsers(List<?> users) {
this.users = users;
}
public List<?> getYdbaike() {
return ydbaike;
}
public void setYdbaike(List<?> ydbaike) {
this.ydbaike = ydbaike;
}
public int getReplyCount() {
return replyCount;
}
public void setReplyCount(int replyCount) {
this.replyCount = replyCount;
}
public List<?> getLink() {
return link;
}
public void setLink(List<?> link) {
this.link = link;
}
public List<ImgBean> getImg() {
return img;
}
public void setImg(List<ImgBean> img) {
this.img = img;
}
public List<?> getVotes() {
return votes;
}
public void setVotes(List<?> votes) {
this.votes = votes;
}
public String getShareLink() {
return shareLink;
}
public void setShareLink(String shareLink) {
this.shareLink = shareLink;
}
public String getDigest() {
return digest;
}
public void setDigest(String digest) {
this.digest = digest;
}
public List<?> getTopiclist_news() {
return topiclist_news;
}
public void setTopiclist_news(List<?> topiclist_news) {
this.topiclist_news = topiclist_news;
}
public String getDkeys() {
return dkeys;
}
public void setDkeys(String dkeys) {
this.dkeys = dkeys;
}
public List<?> getTopiclist() {
return topiclist;
}
public void setTopiclist(List<?> topiclist) {
this.topiclist = topiclist;
}
public String getDocid() {
return docid;
}
public void setDocid(String docid) {
this.docid = docid;
}
public boolean isPicnews() {
return picnews;
}
public void setPicnews(boolean picnews) {
this.picnews = picnews;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getTid() {
return tid;
}
public void setTid(String tid) {
this.tid = tid;
}
public String getTemplate() {
return template;
}
public void setTemplate(String template) {
this.template = template;
}
public int getThreadVote() {
return threadVote;
}
public void setThreadVote(int threadVote) {
this.threadVote = threadVote;
}
public int getThreadAgainst() {
return threadAgainst;
}
public void setThreadAgainst(int threadAgainst) {
this.threadAgainst = threadAgainst;
}
public List<?> getBoboList() {
return boboList;
}
public void setBoboList(List<?> boboList) {
this.boboList = boboList;
}
public String getReplyBoard() {
return replyBoard;
}
public void setReplyBoard(String replyBoard) {
this.replyBoard = replyBoard;
}
public List<HuatiBean> getHuati() {
return huati;
}
public void setHuati(List<HuatiBean> huati) {
this.huati = huati;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public boolean isHasNext() {
return hasNext;
}
public void setHasNext(boolean hasNext) {
this.hasNext = hasNext;
}
public String getVoicecomment() {
return voicecomment;
}
public void setVoicecomment(String voicecomment) {
this.voicecomment = voicecomment;
}
public List<RelativeSysBean> getRelative_sys() {
return relative_sys;
}
public void setRelative_sys(List<RelativeSysBean> relative_sys) {
this.relative_sys = relative_sys;
}
public String getPtime() {
return ptime;
}
public void setPtime(String ptime) {
this.ptime = ptime;
}
@Override
public String toString() {
return "NewsDetail{" +
"body='" + body + '\'' +
'}';
}
/** -- img --
* "ref": "<!--IMG#0-->",
* "pixel": "1280*864",
* "alt": "【西行漫记】梅西，从\"神\"到\"囚徒\"",
* "src": "http://img3.cache.netease.com/photo/0005/2013-09-27/99QFNRRA00DE0005.jpg",
* "photosetID": "0005|108305"
*/
public static class ImgBean{
private String ref;
private String pixel;
private String alt;
private String src;
private String photosetID;
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}
public String getPixel() {
return pixel;
}
public void setPixel(String pixel) {
this.pixel = pixel;
}
public String getAlt() {
return alt;
}
public void setAlt(String alt) {
this.alt = alt;
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
public String getPhotosetID() {
return photosetID;
}
public void setPhotosetID(String photosetID) {
this.photosetID = photosetID;
}
}
/** -- huati --
* "topicId": "SJ06381321305231149983",
* "topicName": "“球王”梅西"
*/
public static class HuatiBean{
private String topicId;
private String topicName;
public String getTopicId() {
return topicId;
}
public void setTopicId(String topicId) {
this.topicId = topicId;
}
public String getTopicName() {
return topicName;
}
public void setTopicName(String topicName) {
this.topicName = topicName;
}
}
/**
* -- relative_sys --
* "id": "BTA6AQJ005298H53",
*"title": "连主帅都请不到！阿根廷这帮人完爆中国足协",
*"source": "肆客足球App",
*"imgsrc": "http://dingyue.nosdn.127.net/uW4cpEppySJP5cbRUCx1cMD4pwTtOC1jkH9chUQXBOITC1469937825638.jpg",
*"docID": "BTA6AQJ005298H53",
*"from": "HZ",
*"type": "doc",
*"ptime": "2016-07-31 12:03:45",
*"href": ""
*/
public static class RelativeSysBean{
private String id;
private String title;
private String source;
private String imgsrc;
private String docID;
private String from;
private String type;
private String ptime;
private String href;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public String getImgsrc() {
return imgsrc;
}
public void setImgsrc(String imgsrc) {
this.imgsrc = imgsrc;
}
public String getDocID() {
return docID;
}
public void setDocID(String docID) {
this.docID = docID;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getPtime() {
return ptime;
}
public void setPtime(String ptime) {
this.ptime = ptime;
}
public String getHref() {
return href;
}
public void setHref(String href) {
this.href = href;
}
}
}
| LuoboDcom/ZZShow | app/src/main/java/com/ys/yoosir/zzshow/mvp/model/entity/netease/NewsDetail.java | 3,408 | /**
*
*"body": "<p> 5300万欧元，约为4.5亿人民币。对于绝大多数人而言，这是一生都不可能积累到的财富。但在过去的一年中，梅西为西班牙税务部门缴纳的税款总额，竟然高达5300万欧元！毫无疑问，梅西已经成了西班牙的“顶级纳税人”。</p><!--IMG#0--><p> 据《世界体育报》报道，梅西上缴的这5300万欧元税款，分为两个部分。一部分是过去一年间他所应缴纳的常规税款，这包括他的个人所得税、财产税以及肖像权收入所产生的税款。另一部分，则与他的偷税纳税事件有关。在2007到2009年，梅西被证实的确偷税纳税。在此事被调查后，梅西立刻组织财务团队自行查账，并补缴了2010年到2012年这三年间所偷漏的税款。</p><p> 梅西在这一年内的缴税金额，很可能还将继续增加。由于偷税漏税事件，梅西很可能会在近期被迫向税务部门缴纳一笔300万欧元的罚款。这也就意味着，梅西在一年内的缴税总金额将极有可能达到5600万欧元。而在过去7年中，梅西向西班牙税务部门缴纳的税款总额已经超过了1亿欧元。</p><!--IMG#1--><p> 在世界杯淘汰赛中，梅西没有进球，阿根廷也最终输给德国名列亚军。就连阿根廷传奇肯佩斯都不满梅西，他批评梅西在淘汰赛中隐身。针对外界对梅西的批评，阿根廷精神领袖马斯切拉诺为跳蚤出头。在小马哥看来，梅西挨批是一件非常不公平的事情。</p><p> “对梅西的批评令人心痛，这不公平。没有梅西的话，我们根本不可能打进世界杯决赛。”马斯切拉诺表态，“萨维利亚？三年来他展现了能力和真诚，我希望他能留下，因为我相信我们已经证明了自己的实力。”</p>",
*"users": [],
*"ydbaike": [],
*"replyCount": 5586,
*"link": [],
*"img": [],
*"votes": [],
*"shareLink": "http://c.m.163.com/news/a/A1E29FK800051C8V.html?spss=newsapp&spsw=1",
*"digest": "",
*"topiclist_news": [],
*"dkeys": "梅西",
*"topiclist": [],
*"docid": "A1E29FK800051C8V",
*"picnews": true,
*"title": "梅西一年内缴税达5300万欧元",
*"tid": "",
*"template": "normal1",
*"threadVote": 1,
*"threadAgainst": 5,
*"boboList": [],
*"replyBoard": "sports2_bbs",
*"huati": [],
*"source": "网易体育",
*"hasNext": false,
*"voicecomment": "off",
*"relative_sys": [],
* "ptime": "2014-07-18 08:28:15"
*/ | block_comment | zh-cn | package com.ys.yoosir.zzshow.mvp.model.entity.netease;
import java.util.List;
/**
* 新闻详情
* @version 1.0
* Created by Yoosir on 2016/11/15 0015.
*/
public class NewsDetail {
/**
*
*"bo <SUF>*/
private String body;
private List<?> users;
private List<?> ydbaike;
private int replyCount;
private List<?> link;
private List<ImgBean> img;
private List<?> votes;
private String shareLink;
private String digest;
private List<?> topiclist_news;
private String dkeys;
private List<?> topiclist;
private String docid;
private boolean picnews;
private String title;
private String tid;
private String template;
private int threadVote;
private int threadAgainst;
private List<?> boboList;
private String replyBoard;
private List<HuatiBean> huati;
private String source;
private boolean hasNext;
private String voicecomment;
private List<RelativeSysBean> relative_sys;
private String ptime;
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public List<?> getUsers() {
return users;
}
public void setUsers(List<?> users) {
this.users = users;
}
public List<?> getYdbaike() {
return ydbaike;
}
public void setYdbaike(List<?> ydbaike) {
this.ydbaike = ydbaike;
}
public int getReplyCount() {
return replyCount;
}
public void setReplyCount(int replyCount) {
this.replyCount = replyCount;
}
public List<?> getLink() {
return link;
}
public void setLink(List<?> link) {
this.link = link;
}
public List<ImgBean> getImg() {
return img;
}
public void setImg(List<ImgBean> img) {
this.img = img;
}
public List<?> getVotes() {
return votes;
}
public void setVotes(List<?> votes) {
this.votes = votes;
}
public String getShareLink() {
return shareLink;
}
public void setShareLink(String shareLink) {
this.shareLink = shareLink;
}
public String getDigest() {
return digest;
}
public void setDigest(String digest) {
this.digest = digest;
}
public List<?> getTopiclist_news() {
return topiclist_news;
}
public void setTopiclist_news(List<?> topiclist_news) {
this.topiclist_news = topiclist_news;
}
public String getDkeys() {
return dkeys;
}
public void setDkeys(String dkeys) {
this.dkeys = dkeys;
}
public List<?> getTopiclist() {
return topiclist;
}
public void setTopiclist(List<?> topiclist) {
this.topiclist = topiclist;
}
public String getDocid() {
return docid;
}
public void setDocid(String docid) {
this.docid = docid;
}
public boolean isPicnews() {
return picnews;
}
public void setPicnews(boolean picnews) {
this.picnews = picnews;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getTid() {
return tid;
}
public void setTid(String tid) {
this.tid = tid;
}
public String getTemplate() {
return template;
}
public void setTemplate(String template) {
this.template = template;
}
public int getThreadVote() {
return threadVote;
}
public void setThreadVote(int threadVote) {
this.threadVote = threadVote;
}
public int getThreadAgainst() {
return threadAgainst;
}
public void setThreadAgainst(int threadAgainst) {
this.threadAgainst = threadAgainst;
}
public List<?> getBoboList() {
return boboList;
}
public void setBoboList(List<?> boboList) {
this.boboList = boboList;
}
public String getReplyBoard() {
return replyBoard;
}
public void setReplyBoard(String replyBoard) {
this.replyBoard = replyBoard;
}
public List<HuatiBean> getHuati() {
return huati;
}
public void setHuati(List<HuatiBean> huati) {
this.huati = huati;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public boolean isHasNext() {
return hasNext;
}
public void setHasNext(boolean hasNext) {
this.hasNext = hasNext;
}
public String getVoicecomment() {
return voicecomment;
}
public void setVoicecomment(String voicecomment) {
this.voicecomment = voicecomment;
}
public List<RelativeSysBean> getRelative_sys() {
return relative_sys;
}
public void setRelative_sys(List<RelativeSysBean> relative_sys) {
this.relative_sys = relative_sys;
}
public String getPtime() {
return ptime;
}
public void setPtime(String ptime) {
this.ptime = ptime;
}
@Override
public String toString() {
return "NewsDetail{" +
"body='" + body + '\'' +
'}';
}
/** -- img --
* "ref": "<!--IMG#0-->",
* "pixel": "1280*864",
* "alt": "【西行漫记】梅西，从\"神\"到\"囚徒\"",
* "src": "http://img3.cache.netease.com/photo/0005/2013-09-27/99QFNRRA00DE0005.jpg",
* "photosetID": "0005|108305"
*/
public static class ImgBean{
private String ref;
private String pixel;
private String alt;
private String src;
private String photosetID;
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}
public String getPixel() {
return pixel;
}
public void setPixel(String pixel) {
this.pixel = pixel;
}
public String getAlt() {
return alt;
}
public void setAlt(String alt) {
this.alt = alt;
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
public String getPhotosetID() {
return photosetID;
}
public void setPhotosetID(String photosetID) {
this.photosetID = photosetID;
}
}
/** -- huati --
* "topicId": "SJ06381321305231149983",
* "topicName": "“球王”梅西"
*/
public static class HuatiBean{
private String topicId;
private String topicName;
public String getTopicId() {
return topicId;
}
public void setTopicId(String topicId) {
this.topicId = topicId;
}
public String getTopicName() {
return topicName;
}
public void setTopicName(String topicName) {
this.topicName = topicName;
}
}
/**
* -- relative_sys --
* "id": "BTA6AQJ005298H53",
*"title": "连主帅都请不到！阿根廷这帮人完爆中国足协",
*"source": "肆客足球App",
*"imgsrc": "http://dingyue.nosdn.127.net/uW4cpEppySJP5cbRUCx1cMD4pwTtOC1jkH9chUQXBOITC1469937825638.jpg",
*"docID": "BTA6AQJ005298H53",
*"from": "HZ",
*"type": "doc",
*"ptime": "2016-07-31 12:03:45",
*"href": ""
*/
public static class RelativeSysBean{
private String id;
private String title;
private String source;
private String imgsrc;
private String docID;
private String from;
private String type;
private String ptime;
private String href;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getSource() {
return source;
}
public void setSource(String source) {
this.source = source;
}
public String getImgsrc() {
return imgsrc;
}
public void setImgsrc(String imgsrc) {
this.imgsrc = imgsrc;
}
public String getDocID() {
return docID;
}
public void setDocID(String docID) {
this.docID = docID;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getPtime() {
return ptime;
}
public void setPtime(String ptime) {
this.ptime = ptime;
}
public String getHref() {
return href;
}
public void setHref(String href) {
this.href = href;
}
}
}
| false |
26193_11 | package cn.mailu.LushX.constant;
public enum VideoTypeEnum {
YK_TV_HOT(1), // 优酷-电视剧
YK_MOVIE_HOT(2), // 优酷-电影
YK_ZY_HOT(3), // 优酷-综艺
YK_DM_HOT(4),//优酷-动漫
YK_TV_NEW(5), // 优酷-电视剧
YK_MOVIE_NEW(6), // 优酷-电影
YK_ZY_NEW(7), // 优酷-综艺
YK_DM_NEW(8),//优酷-动漫
IQY_TV(11), // 爱奇艺-电视剧
IQY_MOVIE(12), // 爱奇艺-电影
IQY_ZY(13), // 爱奇艺-综艺
IQY_DM(14), // 爱奇艺-动漫
CL_SEARCH(20),//尘落-搜索
CL_TV_HOT(21),//~~-电视-最热
CL_MOVIES_HOT(22),//~~-电影-最热
CL_ZY_HOT(23),//~~-综艺-最热
CL_DM_HOT(24),//~~-动漫-最热
CL_TV_NEW(25),//~~-电视-最新
CL_MOVIES_NEW(26),//~~-电影-最新
CL_ZY_NEW(27),//~~-综艺-最新
CL_DM_NEW(28);//~~-动漫-最新
private int code;
VideoTypeEnum(int code){
this.code = code;
}
public int getCode() {
return code;
}
}
| LushX/LushX-BE | src/main/java/cn/mailu/LushX/constant/VideoTypeEnum.java | 442 | // 爱奇艺-动漫 | line_comment | zh-cn | package cn.mailu.LushX.constant;
public enum VideoTypeEnum {
YK_TV_HOT(1), // 优酷-电视剧
YK_MOVIE_HOT(2), // 优酷-电影
YK_ZY_HOT(3), // 优酷-综艺
YK_DM_HOT(4),//优酷-动漫
YK_TV_NEW(5), // 优酷-电视剧
YK_MOVIE_NEW(6), // 优酷-电影
YK_ZY_NEW(7), // 优酷-综艺
YK_DM_NEW(8),//优酷-动漫
IQY_TV(11), // 爱奇艺-电视剧
IQY_MOVIE(12), // 爱奇艺-电影
IQY_ZY(13), // 爱奇艺-综艺
IQY_DM(14), // 爱奇 <SUF>
CL_SEARCH(20),//尘落-搜索
CL_TV_HOT(21),//~~-电视-最热
CL_MOVIES_HOT(22),//~~-电影-最热
CL_ZY_HOT(23),//~~-综艺-最热
CL_DM_HOT(24),//~~-动漫-最热
CL_TV_NEW(25),//~~-电视-最新
CL_MOVIES_NEW(26),//~~-电影-最新
CL_ZY_NEW(27),//~~-综艺-最新
CL_DM_NEW(28);//~~-动漫-最新
private int code;
VideoTypeEnum(int code){
this.code = code;
}
public int getCode() {
return code;
}
}
| false |
44332_12 | package hw9;
public class Hw9_2 {
public static void main(String[] args) {
Account account = new Account(); // 建立帳戶物件
Mom mom = new Mom(account); // 建立媽媽執行緒
Son son = new Son(account); // 建立熊大執行緒
mom.start();
son.start();
}
}
class Account{
private int balance = 0; //存款餘額
public Account() {
}
//媽媽進行存款
synchronized public void deposit(int money) { //餘額超過3000元,就會停止匯款給熊大
while (balance > 3000) {
System.out.println("媽媽看到餘額在3000以上，暫停匯款");
try {
System.out.println("熊大被老媽告知帳戶已經有錢!");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
balance += money;
System.out.println("媽媽存了：" + money + "；帳戶共有：" + balance);
notify(); //喚醒爭奪執行緒
}
//熊大進行提款
synchronized void withdraw(int money) {
//帳戶餘額低於熊大要提款的金額,熊大就會暫停提款
while (balance == 0) {
System.out.println("熊大看到帳戶沒錢，暫停提款");
try {
System.out.println("媽媽被熊大要求匯款!");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
balance -= money;
System.out.println("熊大領了：" + money + "；帳戶共有" + balance);
if (balance < 2000) {
System.out.println("熊大看到餘額低於2000，要求匯款");
notify();
}
}
}
// 媽媽執行存款
class Mom extends Thread {
Account account;
public Mom(Account account) {
this.account = account;
}
public void run() {
for (int i = 1; i <= 10; i++) {
account.deposit(2000); // 每次存款2000元
}
}
}
// 熊大執行緒，執行提款操作
class Son extends Thread {
Account account;
public Son(Account account) {
this.account = account;
}
public void run() {
for (int i = 1; i <= 10; i++) {
account.withdraw(1000); // 每次提款一千元
}
}
}
| Luuuirene/CIA101-Homework | src/hw9/Hw9_2.java | 769 | // 每次提款一千元 | line_comment | zh-cn | package hw9;
public class Hw9_2 {
public static void main(String[] args) {
Account account = new Account(); // 建立帳戶物件
Mom mom = new Mom(account); // 建立媽媽執行緒
Son son = new Son(account); // 建立熊大執行緒
mom.start();
son.start();
}
}
class Account{
private int balance = 0; //存款餘額
public Account() {
}
//媽媽進行存款
synchronized public void deposit(int money) { //餘額超過3000元,就會停止匯款給熊大
while (balance > 3000) {
System.out.println("媽媽看到餘額在3000以上，暫停匯款");
try {
System.out.println("熊大被老媽告知帳戶已經有錢!");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
balance += money;
System.out.println("媽媽存了：" + money + "；帳戶共有：" + balance);
notify(); //喚醒爭奪執行緒
}
//熊大進行提款
synchronized void withdraw(int money) {
//帳戶餘額低於熊大要提款的金額,熊大就會暫停提款
while (balance == 0) {
System.out.println("熊大看到帳戶沒錢，暫停提款");
try {
System.out.println("媽媽被熊大要求匯款!");
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
balance -= money;
System.out.println("熊大領了：" + money + "；帳戶共有" + balance);
if (balance < 2000) {
System.out.println("熊大看到餘額低於2000，要求匯款");
notify();
}
}
}
// 媽媽執行存款
class Mom extends Thread {
Account account;
public Mom(Account account) {
this.account = account;
}
public void run() {
for (int i = 1; i <= 10; i++) {
account.deposit(2000); // 每次存款2000元
}
}
}
// 熊大執行緒，執行提款操作
class Son extends Thread {
Account account;
public Son(Account account) {
this.account = account;
}
public void run() {
for (int i = 1; i <= 10; i++) {
account.withdraw(1000); // 每次 <SUF>
}
}
}
| false |
8700_12 | package com.lwk.familycontact.project.main.view;
import android.content.Intent;
import android.graphics.Color;
import android.support.annotation.NonNull;
import android.support.v4.app.Fragment;
import android.view.Gravity;
import android.view.View;
import com.ashokvarma.bottomnavigation.BadgeItem;
import com.ashokvarma.bottomnavigation.BottomNavigationBar;
import com.ashokvarma.bottomnavigation.BottomNavigationItem;
import com.lib.base.widget.CommonActionBar;
import com.lwk.familycontact.R;
import com.lwk.familycontact.base.FCBaseActivity;
import com.lwk.familycontact.project.common.version.CheckVersionUtils;
import com.lwk.familycontact.project.common.version.VersionBean;
import com.lwk.familycontact.project.contact.view.AddFriendActivity;
import com.lwk.familycontact.project.contact.view.ContactFragment;
import com.lwk.familycontact.project.conversation.view.ConversationFragment;
import com.lwk.familycontact.project.dial.view.DialFragment;
import com.lwk.familycontact.project.main.presenter.MainPresenter;
import com.lwk.familycontact.project.profile.UserProfileActivity;
import com.lwk.familycontact.project.setting.view.SettingActivity;
import com.lwk.familycontact.utils.event.ComNotifyConfig;
import com.lwk.familycontact.utils.event.ComNotifyEventBean;
import com.lwk.familycontact.utils.event.EventBusHelper;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
/**
* MainActivity
* 管理三个主片段
*/
public class MainActivity extends FCBaseActivity implements MainView
, BottomNavigationBar.OnTabSelectedListener
, MainMenuPop.onMenuClickListener
{
private MainPresenter mPresenter;
private CommonActionBar mActionBar;
private BottomNavigationBar mNavigationBar;
private BadgeItem mBadge01;
private BadgeItem mBadge02;
private Fragment mCurFragment;
private ConversationFragment mFragment01;
private ContactFragment mFragment02;
private DialFragment mFragment03;
private MainMenuPop mMenuPop;
@Override
protected int setContentViewId()
{
mPresenter = new MainPresenter(this, mMainHandler);
EventBusHelper.getInstance().regist(this);
return R.layout.activity_main;
}
@Override
protected void initUI()
{
mActionBar = findView(R.id.cab_main);
mActionBar.setRightImgResource(R.drawable.ic_cab_plus_menu);
mActionBar.setRightLayoutClickListener(this);
mNavigationBar = findView(R.id.bnb_main);
mBadge01 = createBadgeItem();
mBadge02 = createBadgeItem();
//这里真他妈扯淡！
//源码中将firstSelectedPosition设置为0
//在navigationbar调用initialise()后就将firstSelectedPosition赋值给内部变量mSelectedPosition，但是不触发监听
//此时手动调用selectTab(0, true)时，监听里触发的不是onTabSelected()，而是他妈的onTabReselected()！！！！
//所以想要在一开始默认选中第一个tab并且能触发监听里的onTabSelected()，就必须先将firstSelectedPosition设置为小于0的数
mNavigationBar.setFirstSelectedPosition(-1);
mNavigationBar
.addItem(createBottomNavigationItem(R.drawable.ic_tab_conversation, R.string.label_main_tab01).setBadgeItem(mBadge01))
.addItem(createBottomNavigationItem(R.drawable.ic_tab_contact, R.string.label_main_tab02).setBadgeItem(mBadge02))
.addItem(createBottomNavigationItem(R.drawable.ic_tab_dial, R.string.label_main_tab03))
.initialise();
mNavigationBar.setTabSelectedListener(this);
//默认选中第一个tab
mNavigationBar.selectTab(0, true);
}
//创建navigationbar的tab
private BottomNavigationItem createBottomNavigationItem(@NonNull int imgResId, @NonNull int titleResId)
{
BottomNavigationItem navigationItem = new BottomNavigationItem(imgResId, titleResId);
navigationItem.setActiveColorResource(R.color.bnbActiveColor);
navigationItem.setInActiveColorResource(R.color.bnbInActiveColor);
return navigationItem;
}
//创建tab的角标
private BadgeItem createBadgeItem()
{
BadgeItem badgeItem = new BadgeItem();
badgeItem.setHideOnSelect(false);
badgeItem.setBorderColor(Color.WHITE);
badgeItem.setBorderWidth(1);
badgeItem.setGravity(Gravity.RIGHT | Gravity.TOP);
badgeItem.setTextColor(Color.WHITE);
badgeItem.setBackgroundColor(Color.RED);
return badgeItem;
}
@Override
protected void initData()
{
super.initData();
//刷新各Tab的角标
mPresenter.refreshLeftTabBadge();
mPresenter.refreshMiddleTabBadge();
}
@Override
protected void onStart()
{
super.onStart();
//检查版本更新
mPresenter.checkVersion();
}
@Override
protected void onClick(int id, View v)
{
switch (id)
{
case R.id.fl_common_actionbar_right:
if (mMenuPop != null)
{
mMenuPop.dismiss();
mMenuPop = null;
}
mMenuPop = new MainMenuPop(this, this);
mMenuPop.showAsDropDown(mActionBar.getRightLayout(), 0, 0);
break;
}
}
@Override
public void onTabSelected(int position)
{
switch (position)
{
case 0:
if (mFragment01 == null)
mFragment01 = ConversationFragment.newInstance();
checkFragment(mFragment01);
mActionBar.setTitleText(R.string.tv_main_actionbar_tab01);
break;
case 1:
if (mFragment02 == null)
mFragment02 = ContactFragment.newInstance();
checkFragment(mFragment02);
mActionBar.setTitleText(R.string.tv_main_actionbar_tab02);
break;
case 2:
if (mFragment03 == null)
mFragment03 = DialFragment.newInstance();
checkFragment(mFragment03);
mActionBar.setTitleText(R.string.tv_main_actionbar_tab03);
break;
}
}
@Override
public void onTabUnselected(int position)
{
}
@Override
public void onTabReselected(int position)
{
switch (position)
{
case 1:
mFragment02.scrollToTop();
break;
case 2:
mFragment01.scrollToTop();
break;
}
}
//切换片段的方法
private void checkFragment(Fragment fragment)
{
//第一次加载片段
if (mCurFragment == null)
{
getSupportFragmentManager().beginTransaction().replace(R.id.ll_main_container, fragment).commit();
mCurFragment = fragment;
return;
}
//相同的tab不做操作
if (mCurFragment == fragment)
{
return;
} else
{
if (fragment.isAdded())
getSupportFragmentManager().beginTransaction()
.hide(mCurFragment).show(fragment).commit();
else
getSupportFragmentManager().beginTransaction()
.hide(mCurFragment).add(R.id.ll_main_container, fragment).commit();
mCurFragment = fragment;
}
}
@Override
public void onBackPressed()
{
moveTaskToBack(true);
}
@Override
public void onClickProfile()
{
startActivity(new Intent(MainActivity.this, UserProfileActivity.class));
}
@Override
public void onClickAddUser()
{
startActivity(new Intent(MainActivity.this, AddFriendActivity.class));
}
@Override
public void onClickSetting()
{
startActivity(new Intent(MainActivity.this, SettingActivity.class));
}
@Override
protected void onDestroy()
{
EventBusHelper.getInstance().unregist(this);
super.onDestroy();
}
@Override
public void onShowFirstBadgeNum(int num)
{
if (mBadge01 != null)
{
mBadge01.show();
mBadge01.setText(String.valueOf(num));
}
}
@Override
public void onHideFirstBadgeNum()
{
if (mBadge01 != null)
mBadge01.hide();
}
@Override
public void onShowMiddleBadgeNum(int num)
{
if (mBadge02 != null)
{
mBadge02.setText(String.valueOf(num));
mBadge02.show();
}
}
@Override
public void onHideMiddleBadgeNum()
{
if (mBadge02 != null)
mBadge02.hide();
}
@Override
public void showVersionDialog(VersionBean versionBean)
{
CheckVersionUtils.getInstance().showVersionDialog(this, versionBean);
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onNotifyEventReceived(ComNotifyEventBean eventBean)
{
switch (eventBean.getFlag())
{
case ComNotifyConfig.REFRESH_USER_INVITE:
mPresenter.refreshMiddleTabBadge();
break;
case ComNotifyConfig.REFRESH_UNREAD_MSG:
mPresenter.refreshLeftTabBadge();
break;
}
}
}
| LwkCoder/FamilyChat | app/src/main/java/com/lwk/familycontact/project/main/view/MainActivity.java | 2,274 | //第一次加载片段
| line_comment | zh-cn | package com.lwk.familycontact.project.main.view;
import android.content.Intent;
import android.graphics.Color;
import android.support.annotation.NonNull;
import android.support.v4.app.Fragment;
import android.view.Gravity;
import android.view.View;
import com.ashokvarma.bottomnavigation.BadgeItem;
import com.ashokvarma.bottomnavigation.BottomNavigationBar;
import com.ashokvarma.bottomnavigation.BottomNavigationItem;
import com.lib.base.widget.CommonActionBar;
import com.lwk.familycontact.R;
import com.lwk.familycontact.base.FCBaseActivity;
import com.lwk.familycontact.project.common.version.CheckVersionUtils;
import com.lwk.familycontact.project.common.version.VersionBean;
import com.lwk.familycontact.project.contact.view.AddFriendActivity;
import com.lwk.familycontact.project.contact.view.ContactFragment;
import com.lwk.familycontact.project.conversation.view.ConversationFragment;
import com.lwk.familycontact.project.dial.view.DialFragment;
import com.lwk.familycontact.project.main.presenter.MainPresenter;
import com.lwk.familycontact.project.profile.UserProfileActivity;
import com.lwk.familycontact.project.setting.view.SettingActivity;
import com.lwk.familycontact.utils.event.ComNotifyConfig;
import com.lwk.familycontact.utils.event.ComNotifyEventBean;
import com.lwk.familycontact.utils.event.EventBusHelper;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
/**
* MainActivity
* 管理三个主片段
*/
public class MainActivity extends FCBaseActivity implements MainView
, BottomNavigationBar.OnTabSelectedListener
, MainMenuPop.onMenuClickListener
{
private MainPresenter mPresenter;
private CommonActionBar mActionBar;
private BottomNavigationBar mNavigationBar;
private BadgeItem mBadge01;
private BadgeItem mBadge02;
private Fragment mCurFragment;
private ConversationFragment mFragment01;
private ContactFragment mFragment02;
private DialFragment mFragment03;
private MainMenuPop mMenuPop;
@Override
protected int setContentViewId()
{
mPresenter = new MainPresenter(this, mMainHandler);
EventBusHelper.getInstance().regist(this);
return R.layout.activity_main;
}
@Override
protected void initUI()
{
mActionBar = findView(R.id.cab_main);
mActionBar.setRightImgResource(R.drawable.ic_cab_plus_menu);
mActionBar.setRightLayoutClickListener(this);
mNavigationBar = findView(R.id.bnb_main);
mBadge01 = createBadgeItem();
mBadge02 = createBadgeItem();
//这里真他妈扯淡！
//源码中将firstSelectedPosition设置为0
//在navigationbar调用initialise()后就将firstSelectedPosition赋值给内部变量mSelectedPosition，但是不触发监听
//此时手动调用selectTab(0, true)时，监听里触发的不是onTabSelected()，而是他妈的onTabReselected()！！！！
//所以想要在一开始默认选中第一个tab并且能触发监听里的onTabSelected()，就必须先将firstSelectedPosition设置为小于0的数
mNavigationBar.setFirstSelectedPosition(-1);
mNavigationBar
.addItem(createBottomNavigationItem(R.drawable.ic_tab_conversation, R.string.label_main_tab01).setBadgeItem(mBadge01))
.addItem(createBottomNavigationItem(R.drawable.ic_tab_contact, R.string.label_main_tab02).setBadgeItem(mBadge02))
.addItem(createBottomNavigationItem(R.drawable.ic_tab_dial, R.string.label_main_tab03))
.initialise();
mNavigationBar.setTabSelectedListener(this);
//默认选中第一个tab
mNavigationBar.selectTab(0, true);
}
//创建navigationbar的tab
private BottomNavigationItem createBottomNavigationItem(@NonNull int imgResId, @NonNull int titleResId)
{
BottomNavigationItem navigationItem = new BottomNavigationItem(imgResId, titleResId);
navigationItem.setActiveColorResource(R.color.bnbActiveColor);
navigationItem.setInActiveColorResource(R.color.bnbInActiveColor);
return navigationItem;
}
//创建tab的角标
private BadgeItem createBadgeItem()
{
BadgeItem badgeItem = new BadgeItem();
badgeItem.setHideOnSelect(false);
badgeItem.setBorderColor(Color.WHITE);
badgeItem.setBorderWidth(1);
badgeItem.setGravity(Gravity.RIGHT | Gravity.TOP);
badgeItem.setTextColor(Color.WHITE);
badgeItem.setBackgroundColor(Color.RED);
return badgeItem;
}
@Override
protected void initData()
{
super.initData();
//刷新各Tab的角标
mPresenter.refreshLeftTabBadge();
mPresenter.refreshMiddleTabBadge();
}
@Override
protected void onStart()
{
super.onStart();
//检查版本更新
mPresenter.checkVersion();
}
@Override
protected void onClick(int id, View v)
{
switch (id)
{
case R.id.fl_common_actionbar_right:
if (mMenuPop != null)
{
mMenuPop.dismiss();
mMenuPop = null;
}
mMenuPop = new MainMenuPop(this, this);
mMenuPop.showAsDropDown(mActionBar.getRightLayout(), 0, 0);
break;
}
}
@Override
public void onTabSelected(int position)
{
switch (position)
{
case 0:
if (mFragment01 == null)
mFragment01 = ConversationFragment.newInstance();
checkFragment(mFragment01);
mActionBar.setTitleText(R.string.tv_main_actionbar_tab01);
break;
case 1:
if (mFragment02 == null)
mFragment02 = ContactFragment.newInstance();
checkFragment(mFragment02);
mActionBar.setTitleText(R.string.tv_main_actionbar_tab02);
break;
case 2:
if (mFragment03 == null)
mFragment03 = DialFragment.newInstance();
checkFragment(mFragment03);
mActionBar.setTitleText(R.string.tv_main_actionbar_tab03);
break;
}
}
@Override
public void onTabUnselected(int position)
{
}
@Override
public void onTabReselected(int position)
{
switch (position)
{
case 1:
mFragment02.scrollToTop();
break;
case 2:
mFragment01.scrollToTop();
break;
}
}
//切换片段的方法
private void checkFragment(Fragment fragment)
{
//第一 <SUF>
if (mCurFragment == null)
{
getSupportFragmentManager().beginTransaction().replace(R.id.ll_main_container, fragment).commit();
mCurFragment = fragment;
return;
}
//相同的tab不做操作
if (mCurFragment == fragment)
{
return;
} else
{
if (fragment.isAdded())
getSupportFragmentManager().beginTransaction()
.hide(mCurFragment).show(fragment).commit();
else
getSupportFragmentManager().beginTransaction()
.hide(mCurFragment).add(R.id.ll_main_container, fragment).commit();
mCurFragment = fragment;
}
}
@Override
public void onBackPressed()
{
moveTaskToBack(true);
}
@Override
public void onClickProfile()
{
startActivity(new Intent(MainActivity.this, UserProfileActivity.class));
}
@Override
public void onClickAddUser()
{
startActivity(new Intent(MainActivity.this, AddFriendActivity.class));
}
@Override
public void onClickSetting()
{
startActivity(new Intent(MainActivity.this, SettingActivity.class));
}
@Override
protected void onDestroy()
{
EventBusHelper.getInstance().unregist(this);
super.onDestroy();
}
@Override
public void onShowFirstBadgeNum(int num)
{
if (mBadge01 != null)
{
mBadge01.show();
mBadge01.setText(String.valueOf(num));
}
}
@Override
public void onHideFirstBadgeNum()
{
if (mBadge01 != null)
mBadge01.hide();
}
@Override
public void onShowMiddleBadgeNum(int num)
{
if (mBadge02 != null)
{
mBadge02.setText(String.valueOf(num));
mBadge02.show();
}
}
@Override
public void onHideMiddleBadgeNum()
{
if (mBadge02 != null)
mBadge02.hide();
}
@Override
public void showVersionDialog(VersionBean versionBean)
{
CheckVersionUtils.getInstance().showVersionDialog(this, versionBean);
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onNotifyEventReceived(ComNotifyEventBean eventBean)
{
switch (eventBean.getFlag())
{
case ComNotifyConfig.REFRESH_USER_INVITE:
mPresenter.refreshMiddleTabBadge();
break;
case ComNotifyConfig.REFRESH_UNREAD_MSG:
mPresenter.refreshLeftTabBadge();
break;
}
}
}
| false |
11105_7 | package com.lyd.wx.task;
import com.lyd.wx.pojo.*;
import com.lyd.wx.uitls.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import java.text.ParseException;
/**
* 描述:
*
* @author liyadong
* @create 2022-08-22-16:21-周一
*/
@Component
public class Send {
@Autowired
RestTemplate restTemplate;
@Autowired
MyWx wx;
/**
* 发送天气数据
* @param token
* @param w
* @throws ParseException
*/
public void send1(String token, Weather w, String userid) throws ParseException {
String url="https://api.weixin.qq.com/cgi-bin/message/template/send?access_token="+token;
String c1="#fdcbf1";
SendJson sendJson = new SendJson();
sendJson.setTouser(userid);
sendJson.setTemplate_id(wx.getTempateid1());
sendJson.setTopcolor(c1);
//数据
SendData sendData = new SendData();
//城市和日期
sendData.setCity(new Item(w.getCity(),"#f093fb"));
sendData.setDate(new Item(w.getDate(),"#f093fb"));
sendData.setWeek(new Item(w.getWeek(),"#f093fb"));
//关于空气
sendData.setAir(new Item(w.getAir(),"#0acffe"));
sendData.setAir_level(new Item(w.getAir_level(),"#0acffe"));
sendData.setAir_pm25(new Item(w.getAir_pm25(),"#0acffe"));
sendData.setHumidity(new Item(w.getHumidity(),"#0acffe"));
sendData.setAir_tips(new Item(w.getAir_tips(),"#0acffe"));
sendData.setPressure(new Item(w.getPressure(),"#0acffe"));
sendData.setVisibility(new Item(w.getVisibility(),"#0acffe"));
//关于温度天气
sendData.setTem1(new Item(w.getTem1(),"#f43b47"));
sendData.setTem2(new Item(w.getTem2(),"#f43b47"));
sendData.setWea(new Item(w.getWea(),"#f43b47"));
//关于风
sendData.setWin_meter(new Item(w.getWin_meter(),"#88d3ce"));
sendData.setWin_speed(new Item(w.getWin_speed(),"#88d3ce"));
sendData.setWin(new Item(w.getWin(),"#88d3ce"));
//附加数据
sendData.setTxt1(new Item("亲爱的乖乖宝贝，早上好！ (๑•̀ㅂ•́)و✧记得按时吃早饭午饭晚饭。今天也要开心哦ヽ(✿ﾟ▽ﾟ)ノ","#ff7eb3"));
sendData.setTxt2(new Item("下面由我来给你播报一下今天的天气状况╰(*°▽°*)╯","#f09819"));
//发送请求
sendJson.setData(sendData);
String s = restTemplate.postForObject(url, sendJson, String.class);
System.out.println(s);
}
/**
* 发送纪念日数据
* @param token
*/
public void send2(String token,String userid) throws ParseException {
String url="https://api.weixin.qq.com/cgi-bin/message/template/send?access_token="+token;
String c1="#fdcbf1";
SendJson sendJson = new SendJson();
sendJson.setTouser(userid);
sendJson.setTemplate_id(wx.getTempateid2());
sendJson.setTopcolor(c1);
SendData sd = new SendData();
//距离认识多少天
sd.setDay1(new Item(DateUtils.dayForLastDay(wx.getDay1()),"#fee140"));
//距离在一起多少天
sd.setDay2(new Item(DateUtils.dayForLastDay(wx.getDay2()),"#fee140"));
//距离我生日多少天
sd.setDay3(new Item(DateUtils.dayToBirthday(wx.getDay3()),"#fee140"));
//距离宝贝生日多少天
sd.setDay4(new Item(DateUtils.dayToBirthday(wx.getDay4()),"#fee140"));
//距离我出生多少天
sd.setDay5(new Item(DateUtils.dayForLastDay(wx.getDay3()),"#fee140"));
//距离宝贝出生多少天
sd.setDay6(new Item(DateUtils.dayForLastDay(wx.getDay4()),"#fee140"));
//附加文本数据
sd.setTxt1(new Item("宝贝，今天也很爱你哦(*/ω＼*)","#cd9cf2"));
sd.setTxt2(new Item("还有很长的日子，要一直陪你走下去 *′∀`)′∀`)*′∀`)*′∀`)","#cd9cf2"));
sendJson.setData(sd);
String s = restTemplate.postForObject(url, sendJson, String.class);
System.out.println(s);
}
/**
* 事件提醒
* 可以设置三句话，不同颜色，t文本，c颜色
*/
public void send3(String token,String userid,String t1,String c1,String t2,String c2,String t3,String c3){
String url="https://api.weixin.qq.com/cgi-bin/message/template/send?access_token="+token;
String c="#fdcbf1";
SendJson sendJson = new SendJson();
sendJson.setTouser(userid);
sendJson.setTemplate_id(wx.getTempateid3());
sendJson.setTopcolor(c);
SendData sd = new SendData();
sd.setTxt1(new Item(t1,c1));
sd.setTxt2(new Item(t2,c2));
sd.setTxt3(new Item(t3,c3));
sendJson.setData(sd);
String s = restTemplate.postForObject(url, sendJson, String.class);
System.out.println(s);
}
}
| Lyd889911/wx | src/main/java/com/lyd/wx/task/Send.java | 1,602 | //附加数据 | line_comment | zh-cn | package com.lyd.wx.task;
import com.lyd.wx.pojo.*;
import com.lyd.wx.uitls.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import java.text.ParseException;
/**
* 描述:
*
* @author liyadong
* @create 2022-08-22-16:21-周一
*/
@Component
public class Send {
@Autowired
RestTemplate restTemplate;
@Autowired
MyWx wx;
/**
* 发送天气数据
* @param token
* @param w
* @throws ParseException
*/
public void send1(String token, Weather w, String userid) throws ParseException {
String url="https://api.weixin.qq.com/cgi-bin/message/template/send?access_token="+token;
String c1="#fdcbf1";
SendJson sendJson = new SendJson();
sendJson.setTouser(userid);
sendJson.setTemplate_id(wx.getTempateid1());
sendJson.setTopcolor(c1);
//数据
SendData sendData = new SendData();
//城市和日期
sendData.setCity(new Item(w.getCity(),"#f093fb"));
sendData.setDate(new Item(w.getDate(),"#f093fb"));
sendData.setWeek(new Item(w.getWeek(),"#f093fb"));
//关于空气
sendData.setAir(new Item(w.getAir(),"#0acffe"));
sendData.setAir_level(new Item(w.getAir_level(),"#0acffe"));
sendData.setAir_pm25(new Item(w.getAir_pm25(),"#0acffe"));
sendData.setHumidity(new Item(w.getHumidity(),"#0acffe"));
sendData.setAir_tips(new Item(w.getAir_tips(),"#0acffe"));
sendData.setPressure(new Item(w.getPressure(),"#0acffe"));
sendData.setVisibility(new Item(w.getVisibility(),"#0acffe"));
//关于温度天气
sendData.setTem1(new Item(w.getTem1(),"#f43b47"));
sendData.setTem2(new Item(w.getTem2(),"#f43b47"));
sendData.setWea(new Item(w.getWea(),"#f43b47"));
//关于风
sendData.setWin_meter(new Item(w.getWin_meter(),"#88d3ce"));
sendData.setWin_speed(new Item(w.getWin_speed(),"#88d3ce"));
sendData.setWin(new Item(w.getWin(),"#88d3ce"));
//附加 <SUF>
sendData.setTxt1(new Item("亲爱的乖乖宝贝，早上好！ (๑•̀ㅂ•́)و✧记得按时吃早饭午饭晚饭。今天也要开心哦ヽ(✿ﾟ▽ﾟ)ノ","#ff7eb3"));
sendData.setTxt2(new Item("下面由我来给你播报一下今天的天气状况╰(*°▽°*)╯","#f09819"));
//发送请求
sendJson.setData(sendData);
String s = restTemplate.postForObject(url, sendJson, String.class);
System.out.println(s);
}
/**
* 发送纪念日数据
* @param token
*/
public void send2(String token,String userid) throws ParseException {
String url="https://api.weixin.qq.com/cgi-bin/message/template/send?access_token="+token;
String c1="#fdcbf1";
SendJson sendJson = new SendJson();
sendJson.setTouser(userid);
sendJson.setTemplate_id(wx.getTempateid2());
sendJson.setTopcolor(c1);
SendData sd = new SendData();
//距离认识多少天
sd.setDay1(new Item(DateUtils.dayForLastDay(wx.getDay1()),"#fee140"));
//距离在一起多少天
sd.setDay2(new Item(DateUtils.dayForLastDay(wx.getDay2()),"#fee140"));
//距离我生日多少天
sd.setDay3(new Item(DateUtils.dayToBirthday(wx.getDay3()),"#fee140"));
//距离宝贝生日多少天
sd.setDay4(new Item(DateUtils.dayToBirthday(wx.getDay4()),"#fee140"));
//距离我出生多少天
sd.setDay5(new Item(DateUtils.dayForLastDay(wx.getDay3()),"#fee140"));
//距离宝贝出生多少天
sd.setDay6(new Item(DateUtils.dayForLastDay(wx.getDay4()),"#fee140"));
//附加文本数据
sd.setTxt1(new Item("宝贝，今天也很爱你哦(*/ω＼*)","#cd9cf2"));
sd.setTxt2(new Item("还有很长的日子，要一直陪你走下去 *′∀`)′∀`)*′∀`)*′∀`)","#cd9cf2"));
sendJson.setData(sd);
String s = restTemplate.postForObject(url, sendJson, String.class);
System.out.println(s);
}
/**
* 事件提醒
* 可以设置三句话，不同颜色，t文本，c颜色
*/
public void send3(String token,String userid,String t1,String c1,String t2,String c2,String t3,String c3){
String url="https://api.weixin.qq.com/cgi-bin/message/template/send?access_token="+token;
String c="#fdcbf1";
SendJson sendJson = new SendJson();
sendJson.setTouser(userid);
sendJson.setTemplate_id(wx.getTempateid3());
sendJson.setTopcolor(c);
SendData sd = new SendData();
sd.setTxt1(new Item(t1,c1));
sd.setTxt2(new Item(t2,c2));
sd.setTxt3(new Item(t3,c3));
sendJson.setData(sd);
String s = restTemplate.postForObject(url, sendJson, String.class);
System.out.println(s);
}
}
| false |
47829_0 | public boolean offer(E e){
if(e==NULL)
throw new NullPointerException;
modCount++;
int i=size;
if(i>queue.length)
grow(i+1); //自动扩容
size=i+1;
if(i==0)
queue[0]=e;
else
shiftUp(i,e);
return true;
}
//从k指定的位置开始，将x逐层与当前点的parent进行比较并交换，直到满足x >= queue[parent]为止
private void shiftUp(int k,E x){
while(k>0){
int parent=(k-1)>>>1; //parent=(nodeNo-1)/2
Object e=queue[parent];
if(comparator.compare(x,(E) e)>=0)
break;
queue[k]=e;
k=parent;
}
queue[k]=x;
}
public E poll(){
if(size==0)
return null;
int s=--size;
modCount++;
E result=(E)queue[0];
E x=(E)queue[s];
queue[s]=null;
if(s!=0)
shiftDown(0,x);
return result;
}
private void shiftDown(int k,E x){
int half=size>>>1;
while(k<half){
int child=(k<<1)+1; //leftNo=parentNo*2+1
Object c=queue[child];
int right=child+1;
if(right<size &&
comparator.compare((E)c,(E) queue[right])>0)
c=queue[child=right];
if(comparator.compare(x,(E) c)<=0)
break;
queue[k]=c;
k=child;
}
queue[k]=x;
}
public E peek(){
if(size==0)
return null;
return queue[0];
}
| Lyon-NEU/Java_Learn_old | collections/PriorityQueue.java | 501 | //自动扩容 | line_comment | zh-cn | public boolean offer(E e){
if(e==NULL)
throw new NullPointerException;
modCount++;
int i=size;
if(i>queue.length)
grow(i+1); //自动 <SUF>
size=i+1;
if(i==0)
queue[0]=e;
else
shiftUp(i,e);
return true;
}
//从k指定的位置开始，将x逐层与当前点的parent进行比较并交换，直到满足x >= queue[parent]为止
private void shiftUp(int k,E x){
while(k>0){
int parent=(k-1)>>>1; //parent=(nodeNo-1)/2
Object e=queue[parent];
if(comparator.compare(x,(E) e)>=0)
break;
queue[k]=e;
k=parent;
}
queue[k]=x;
}
public E poll(){
if(size==0)
return null;
int s=--size;
modCount++;
E result=(E)queue[0];
E x=(E)queue[s];
queue[s]=null;
if(s!=0)
shiftDown(0,x);
return result;
}
private void shiftDown(int k,E x){
int half=size>>>1;
while(k<half){
int child=(k<<1)+1; //leftNo=parentNo*2+1
Object c=queue[child];
int right=child+1;
if(right<size &&
comparator.compare((E)c,(E) queue[right])>0)
c=queue[child=right];
if(comparator.compare(x,(E) c)<=0)
break;
queue[k]=c;
k=child;
}
queue[k]=x;
}
public E peek(){
if(size==0)
return null;
return queue[0];
}
| false |
20750_19 | package util;
public final class MessageType {
public MessageType() {
// TODO Auto-generated constructor stub
}
//Message-Type
public static final String operFeedback = "OPER_FEEDBACK";
//管理员：管理用户
public static final String outputAllStudent = "OUTPUT_ALL_STUDENT";
public static final String outputAllTeacher = "OUTPUT_ALL_TEACHER";
public static final String outputAllRetailer = "OUTPUT_ALL_RETAILER";
public static final String outputAllDoctor = "OUTPUT_ALL_DOCTOR";
public static final String addStudent = "ADD_STUDENT";
public static final String deleteStudent = "DELETE_STUDENT";
public static final String updateStudent = "UPDATE_STUDENT";
public static final String queryStudent = "QUERY_STUDENT";
public static final String queryStudentByMajor = "QUERY_STUDENT_BY_MAJOR";
public static final String addTeacher = "ADD_TEACHER";
public static final String deleteTeacher = "DELETE_TEACHER";
public static final String updateTeacher = "UPDATE_TEACHER";
public static final String queryTeacher = "QUERY_TEACHER";
public static final String addRetailer = "ADD_RETAILER";
public static final String deleteRetailer = "DELETE_RETAILER";
public static final String updateRetailer = "UPDATE_RETAILER";
public static final String queryRetailer = "QUERY_RETAILER";
public static final String addDoctor = "ADD_DOCTOR";
public static final String deleteDoctor = "DELETE_DOCTOR";
public static final String updateDoctor = "UPDATE_DOCTOR";
public static final String queryDoctor = "QUERY_DOCTOR";
//用户操作
public static final String userLogin = "USER_LOGIN";
public static final String register = "REGISTER";
//图书馆
public static final String outputallbooks = "OUTPUT_ALL_BOOKS";//返回所有书目
public static final String outputallbooksbystudy="OUTPUT_ALL_BOOKS_BYSTUDY";//学业书籍推荐
public static final String outputallbooksbyhappy="OUTPUT_ALL_BOOKS_BYHAPPY";//休闲书籍推荐
public static final String outputbyindistinctsearch="OUTPUT_BY_INDISTINCTSEARCH";//模糊查询
public static final String outputbybookidsearch="OUTPUT_BY_BOOKIDSEARCH";//通过书ID查询
public static final String outputbybooknamesearch="OUTPUT_BY_BOOKNAMESEARCH";//通过书名查询
public static final String outputbybookauthorsearch="OUTPUT_BY_BOOKAUTHORSEARCH";//通过书的作者查询
public static final String outputbysearchbyrecordstudentidisreturn="OUTPUT_BY_SEARCHBYRECORDSTUDENTIDISRETURN";//返回我的已还
public static final String outputbysearchbyrecordstudentidnotreturn="OUTPUT_BY_SEARCHBYRECORDSTUDENTIDNOTRETURN";//返回我的待还
public static final String outputbysearchbyrecordid="OUTPUTBYSEARCHBYRECORDID";
public static final String insertbook="INSERT_BOOK";//插入书
public static final String deletelibbook="DELETE_LIBBOOK";//删除书
public static final String updatebook="UPDATE_BOOK";//更新书的信息
public static final String returnbook="RETURN_BOOK";//还书
public static final String lendbook="LEND_BOOK";//借书
//商店
public static final String shopQuery = "SHOP_QUERY";//查询商品
public static final String shopInit = "SHOP_INIT";//查询所有
public static final String Buy = "BUY";//购买
public static final String PurchaseRecordQuery = "PURCHASERECORD_QUERY";//查询购买记录
public static final String SellingRecordQuery = "SELLINGRECORD_QUERY";//查询售出记录
public static final String Score = "SCORE";
public static final String shop_queryStudent = "SHOP_QUERYSTUDENT";
public static final String shop_queryRetailer = "SHOP_QUERYRETAILER";
public static final String add_product = "ADD_PRODUCT";
//课程
public static final String course_query = "COURSE_QUERY";//返回所有查询学期的课(学生
public static final String course_query_admin = "COURSE_QUERY_ADMIN";//返回所有查询学期的课(管理员（所有课
public static final String course_init = "COURSE_INIT"; //返回所有本学期的课
public static final String course_choose = "COURSE_CHOOSE";//学生选课，grade表插入记录
public static final String course_my_table = "COURSE_MYTABLE";//返回该学生该学期的课
public static final String course_giveup = "COURSE_GIVEUP";//退课
public static final String course_query_grade = "COURSE_QUERY_GRADE";//查成绩
public static final String course_teacher_table = "COURSE_TEACHER_TABLE";//老师课程表
public static final String course_studentList_query = "COURSE_STUDENTLIST_QUERY";//查询该门课程有哪些学生选择
public static final String course_grade_add = "COURSE_GRADE_ADD";//登成绩
public static final String course_query_course = "COURSE_QUERY_COURSE";//查一门课
public static final String course_exam_add = "COURSE_EXAM_ADD";//发布考试
public static final String course_add = "COURSE_ADD";//管理员加课
//银行
public static final String record_Query = "RECORD_QUERY";//查询交易明细
public static final String phone_Pay = "PHONE_PAY";//支付手机流量包
public static final String wifi_Pay = "WIFI_PAY";//支付校园网套餐
public static final String tuition_Pay = "TUITION_PAY";//支付学费
public static final String card_Invest = "CARD_INVEST";//对一卡通进行充值
public static final String account_Query = "ACCOUNT_QUERY";//查询具体账单金额
//场馆
public static final String place_query_all = "PLACE_QUERY_ALL";//查询场馆列表的公共入口
public static final String place_ap_insert = "PLACE_AP_INSERT";//新增场馆预约
public static final String place_ap_query = "PLACE_AP_QUERY";//场馆预约记录查询（按照场馆
public static final String stu_ap_query = "STU_AP_QUERY";//场馆预约记录查询（按照学生
public static final String place_ap_delete = "PLACE_AP_DELETE";//场馆预约记录取消
public static final String place_query_by_name = "PLACE_QUERY_BY_NAME";//查询特定场馆
//医院
public static final String doc_query_all = "DOC_QUERY_ALL";//返回所有医生（医生表
public static final String doc_query_doc = "DOC_QUERY_DOC";//返回指定医生（医生表
public static final String stu_advice_query_stu = "STU_ADVICE_QUERY_STU";//返回指定学生的咨询记录（咨询记录表
public static final String stu_advice_query_doc = "STU_ADVICE_QUERY_DOC";//返回指定医生的咨询记录（咨询记录表
public static final String stu_res_query = "STU_RES_QUERY";//返回指定学生的挂号记录（挂号记录表
public static final String stu_advice_insert = "STU_ADVICE_INSERT";//增加一条记录（咨询记录表
public static final String stu_res_insert = "STU_RES_INSERT";//增加一条记录（挂号记录表
public static final String stu_advice_query_relevant = "STU_ADVICE_QUERY_RELEVANT";//查询相关问题
public static final String doc_rank = "DOC_RANK";//更新医生的声誉（医生表
public static final String doc_schedule_query = "DOC_SCHEDULE_QUERY";//返回一个医生的出诊安排（医生安排表
public static final String doc_advice_ans = "DOC_ADVICE_ANS";//医生的回复-修改记录（咨询记录表
public static final String doc_schedule_add = "DOC_SCHEDULE_ADD";//添加一个医生的出诊安排（医生安排表
public static final String doc_schedule_del = "DOC_SCHEDULE_DEL";//删除一个医生的出诊安排（医生安排表
} | M-Ethereal/VCampus | src/util/MessageType.java | 2,015 | //查询购买记录 | line_comment | zh-cn | package util;
public final class MessageType {
public MessageType() {
// TODO Auto-generated constructor stub
}
//Message-Type
public static final String operFeedback = "OPER_FEEDBACK";
//管理员：管理用户
public static final String outputAllStudent = "OUTPUT_ALL_STUDENT";
public static final String outputAllTeacher = "OUTPUT_ALL_TEACHER";
public static final String outputAllRetailer = "OUTPUT_ALL_RETAILER";
public static final String outputAllDoctor = "OUTPUT_ALL_DOCTOR";
public static final String addStudent = "ADD_STUDENT";
public static final String deleteStudent = "DELETE_STUDENT";
public static final String updateStudent = "UPDATE_STUDENT";
public static final String queryStudent = "QUERY_STUDENT";
public static final String queryStudentByMajor = "QUERY_STUDENT_BY_MAJOR";
public static final String addTeacher = "ADD_TEACHER";
public static final String deleteTeacher = "DELETE_TEACHER";
public static final String updateTeacher = "UPDATE_TEACHER";
public static final String queryTeacher = "QUERY_TEACHER";
public static final String addRetailer = "ADD_RETAILER";
public static final String deleteRetailer = "DELETE_RETAILER";
public static final String updateRetailer = "UPDATE_RETAILER";
public static final String queryRetailer = "QUERY_RETAILER";
public static final String addDoctor = "ADD_DOCTOR";
public static final String deleteDoctor = "DELETE_DOCTOR";
public static final String updateDoctor = "UPDATE_DOCTOR";
public static final String queryDoctor = "QUERY_DOCTOR";
//用户操作
public static final String userLogin = "USER_LOGIN";
public static final String register = "REGISTER";
//图书馆
public static final String outputallbooks = "OUTPUT_ALL_BOOKS";//返回所有书目
public static final String outputallbooksbystudy="OUTPUT_ALL_BOOKS_BYSTUDY";//学业书籍推荐
public static final String outputallbooksbyhappy="OUTPUT_ALL_BOOKS_BYHAPPY";//休闲书籍推荐
public static final String outputbyindistinctsearch="OUTPUT_BY_INDISTINCTSEARCH";//模糊查询
public static final String outputbybookidsearch="OUTPUT_BY_BOOKIDSEARCH";//通过书ID查询
public static final String outputbybooknamesearch="OUTPUT_BY_BOOKNAMESEARCH";//通过书名查询
public static final String outputbybookauthorsearch="OUTPUT_BY_BOOKAUTHORSEARCH";//通过书的作者查询
public static final String outputbysearchbyrecordstudentidisreturn="OUTPUT_BY_SEARCHBYRECORDSTUDENTIDISRETURN";//返回我的已还
public static final String outputbysearchbyrecordstudentidnotreturn="OUTPUT_BY_SEARCHBYRECORDSTUDENTIDNOTRETURN";//返回我的待还
public static final String outputbysearchbyrecordid="OUTPUTBYSEARCHBYRECORDID";
public static final String insertbook="INSERT_BOOK";//插入书
public static final String deletelibbook="DELETE_LIBBOOK";//删除书
public static final String updatebook="UPDATE_BOOK";//更新书的信息
public static final String returnbook="RETURN_BOOK";//还书
public static final String lendbook="LEND_BOOK";//借书
//商店
public static final String shopQuery = "SHOP_QUERY";//查询商品
public static final String shopInit = "SHOP_INIT";//查询所有
public static final String Buy = "BUY";//购买
public static final String PurchaseRecordQuery = "PURCHASERECORD_QUERY";//查询 <SUF>
public static final String SellingRecordQuery = "SELLINGRECORD_QUERY";//查询售出记录
public static final String Score = "SCORE";
public static final String shop_queryStudent = "SHOP_QUERYSTUDENT";
public static final String shop_queryRetailer = "SHOP_QUERYRETAILER";
public static final String add_product = "ADD_PRODUCT";
//课程
public static final String course_query = "COURSE_QUERY";//返回所有查询学期的课(学生
public static final String course_query_admin = "COURSE_QUERY_ADMIN";//返回所有查询学期的课(管理员（所有课
public static final String course_init = "COURSE_INIT"; //返回所有本学期的课
public static final String course_choose = "COURSE_CHOOSE";//学生选课，grade表插入记录
public static final String course_my_table = "COURSE_MYTABLE";//返回该学生该学期的课
public static final String course_giveup = "COURSE_GIVEUP";//退课
public static final String course_query_grade = "COURSE_QUERY_GRADE";//查成绩
public static final String course_teacher_table = "COURSE_TEACHER_TABLE";//老师课程表
public static final String course_studentList_query = "COURSE_STUDENTLIST_QUERY";//查询该门课程有哪些学生选择
public static final String course_grade_add = "COURSE_GRADE_ADD";//登成绩
public static final String course_query_course = "COURSE_QUERY_COURSE";//查一门课
public static final String course_exam_add = "COURSE_EXAM_ADD";//发布考试
public static final String course_add = "COURSE_ADD";//管理员加课
//银行
public static final String record_Query = "RECORD_QUERY";//查询交易明细
public static final String phone_Pay = "PHONE_PAY";//支付手机流量包
public static final String wifi_Pay = "WIFI_PAY";//支付校园网套餐
public static final String tuition_Pay = "TUITION_PAY";//支付学费
public static final String card_Invest = "CARD_INVEST";//对一卡通进行充值
public static final String account_Query = "ACCOUNT_QUERY";//查询具体账单金额
//场馆
public static final String place_query_all = "PLACE_QUERY_ALL";//查询场馆列表的公共入口
public static final String place_ap_insert = "PLACE_AP_INSERT";//新增场馆预约
public static final String place_ap_query = "PLACE_AP_QUERY";//场馆预约记录查询（按照场馆
public static final String stu_ap_query = "STU_AP_QUERY";//场馆预约记录查询（按照学生
public static final String place_ap_delete = "PLACE_AP_DELETE";//场馆预约记录取消
public static final String place_query_by_name = "PLACE_QUERY_BY_NAME";//查询特定场馆
//医院
public static final String doc_query_all = "DOC_QUERY_ALL";//返回所有医生（医生表
public static final String doc_query_doc = "DOC_QUERY_DOC";//返回指定医生（医生表
public static final String stu_advice_query_stu = "STU_ADVICE_QUERY_STU";//返回指定学生的咨询记录（咨询记录表
public static final String stu_advice_query_doc = "STU_ADVICE_QUERY_DOC";//返回指定医生的咨询记录（咨询记录表
public static final String stu_res_query = "STU_RES_QUERY";//返回指定学生的挂号记录（挂号记录表
public static final String stu_advice_insert = "STU_ADVICE_INSERT";//增加一条记录（咨询记录表
public static final String stu_res_insert = "STU_RES_INSERT";//增加一条记录（挂号记录表
public static final String stu_advice_query_relevant = "STU_ADVICE_QUERY_RELEVANT";//查询相关问题
public static final String doc_rank = "DOC_RANK";//更新医生的声誉（医生表
public static final String doc_schedule_query = "DOC_SCHEDULE_QUERY";//返回一个医生的出诊安排（医生安排表
public static final String doc_advice_ans = "DOC_ADVICE_ANS";//医生的回复-修改记录（咨询记录表
public static final String doc_schedule_add = "DOC_SCHEDULE_ADD";//添加一个医生的出诊安排（医生安排表
public static final String doc_schedule_del = "DOC_SCHEDULE_DEL";//删除一个医生的出诊安排（医生安排表
} | false |
45657_6 | package main ;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class TestForFunction {
//创建一个窗口，在窗口中添加一个按钮，按钮点击时，在JLabel输出helloword
public static void main(String[] args) {
//1.创建一个窗口(JFrame)
JFrame frame=new JFrame("监听器例子");
frame.setLayout(new FlowLayout());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//x 掉窗口推出java程序
//2.设置窗口的位置和大小
frame.setLocation(500, 500);
frame.setSize(300, 250);
//3.创建一个JLable和按钮
final JLabel label=new JLabel("未点击");
JButton btn=new JButton("点我!");
//5.将按钮添加到窗口中
frame.add(label);
frame.add(btn);
//6.创建一个监听器
ActionListener listener = new ActionListener() {
//事件处理器
public void actionPerformed(ActionEvent e) {
label.setText("HelloWord");
System.out.println("HelloWord");
}
};
/**
* 事件源:按钮
* 事件:按钮被点击
* 监听器:Listener
* 将监听器注册到按钮(事件源)上，监听器将会一直监听(监视)按钮的状态变化，一旦按钮被
* 点击（事件发生），将会通知监听器，监听器将会调用特定的方法处理"按钮被点击"
* 事件
*/
//7.注册监听器(让监听器监听指定的按钮)
btn.addActionListener(listener);
//8.设置窗口为显示(状态)
frame.setVisible(true);
}
} | MANNIX-CHEN/Tetris | src/main/TestForFunction.java | 434 | //6.创建一个监听器 | line_comment | zh-cn | package main ;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class TestForFunction {
//创建一个窗口，在窗口中添加一个按钮，按钮点击时，在JLabel输出helloword
public static void main(String[] args) {
//1.创建一个窗口(JFrame)
JFrame frame=new JFrame("监听器例子");
frame.setLayout(new FlowLayout());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//x 掉窗口推出java程序
//2.设置窗口的位置和大小
frame.setLocation(500, 500);
frame.setSize(300, 250);
//3.创建一个JLable和按钮
final JLabel label=new JLabel("未点击");
JButton btn=new JButton("点我!");
//5.将按钮添加到窗口中
frame.add(label);
frame.add(btn);
//6. <SUF>
ActionListener listener = new ActionListener() {
//事件处理器
public void actionPerformed(ActionEvent e) {
label.setText("HelloWord");
System.out.println("HelloWord");
}
};
/**
* 事件源:按钮
* 事件:按钮被点击
* 监听器:Listener
* 将监听器注册到按钮(事件源)上，监听器将会一直监听(监视)按钮的状态变化，一旦按钮被
* 点击（事件发生），将会通知监听器，监听器将会调用特定的方法处理"按钮被点击"
* 事件
*/
//7.注册监听器(让监听器监听指定的按钮)
btn.addActionListener(listener);
//8.设置窗口为显示(状态)
frame.setVisible(true);
}
} | false |
22718_2 | package leetcode.dynamicprogramming;
import leetcode.binarytree.TreeNode;
/**
* @author maxjoker
* @date 2022-05-30 23:50
*
* 337. 打家劫舍 III
* 小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。
*
* 除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。
*
* 给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。
*
*
*
* 示例 1:
*
* https://assets.leetcode.com/uploads/2021/03/10/rob1-tree.jpg
*
*
* 输入: root = [3,2,3,null,3,null,1]
* 输出: 7
* 解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7
* 示例 2:
*
* https://assets.leetcode.com/uploads/2021/03/10/rob2-tree.jpg
*
*
* 输入: root = [3,4,5,1,3,null,1]
* 输出: 9
* 解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9
*
*
* 提示：
*
* 树的节点数在 [1, 10^4] 范围内
* 0 <= Node.val <= 10^4
*
*/
public class HouseRobber3 {
/**
* dp[node][j] ：这里 node 表示一个结点，以 node 为根结点的树，并且规定了 node 是否偷取能够获得的最大价值。
* j = 0 表示 node 结点不偷取；
* j = 1 表示 node 结点偷取。
*
* 根据当前结点偷或者不偷，就决定了需要从哪些子结点里的对应的状态转移过来。
* 如果当前结点不偷，左右子结点偷或者不偷都行，选最大者；
* 如果当前结点偷，左右子结点均不能偷。
*
* @param root
* @return
*/
public static int rob(TreeNode root) {
int[] res = dfs(root);
return Math.max(res[0], res[1]);
}
private static int[] dfs(TreeNode node) {
if (node == null) {
return new int[]{0, 0};
}
// 分类讨论的标准是：当前结点偷或者不偷
// 由于需要后序遍历，所以先计算左右子结点，然后计算当前结点的状态值
int[] left = dfs(node.left);
int[] right = dfs(node.right);
int[] dp = new int[2];
// dp[0]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点不偷
dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
// dp[1]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点偷
dp[1] = node.val + left[0] + right[0];
return dp;
}
}
| MAXJOKER/keep-learning | com.finn/src/main/java/leetcode/dynamicprogramming/HouseRobber3.java | 919 | // 分类讨论的标准是：当前结点偷或者不偷 | line_comment | zh-cn | package leetcode.dynamicprogramming;
import leetcode.binarytree.TreeNode;
/**
* @author maxjoker
* @date 2022-05-30 23:50
*
* 337. 打家劫舍 III
* 小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。
*
* 除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。
*
* 给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。
*
*
*
* 示例 1:
*
* https://assets.leetcode.com/uploads/2021/03/10/rob1-tree.jpg
*
*
* 输入: root = [3,2,3,null,3,null,1]
* 输出: 7
* 解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7
* 示例 2:
*
* https://assets.leetcode.com/uploads/2021/03/10/rob2-tree.jpg
*
*
* 输入: root = [3,4,5,1,3,null,1]
* 输出: 9
* 解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9
*
*
* 提示：
*
* 树的节点数在 [1, 10^4] 范围内
* 0 <= Node.val <= 10^4
*
*/
public class HouseRobber3 {
/**
* dp[node][j] ：这里 node 表示一个结点，以 node 为根结点的树，并且规定了 node 是否偷取能够获得的最大价值。
* j = 0 表示 node 结点不偷取；
* j = 1 表示 node 结点偷取。
*
* 根据当前结点偷或者不偷，就决定了需要从哪些子结点里的对应的状态转移过来。
* 如果当前结点不偷，左右子结点偷或者不偷都行，选最大者；
* 如果当前结点偷，左右子结点均不能偷。
*
* @param root
* @return
*/
public static int rob(TreeNode root) {
int[] res = dfs(root);
return Math.max(res[0], res[1]);
}
private static int[] dfs(TreeNode node) {
if (node == null) {
return new int[]{0, 0};
}
// 分类 <SUF>
// 由于需要后序遍历，所以先计算左右子结点，然后计算当前结点的状态值
int[] left = dfs(node.left);
int[] right = dfs(node.right);
int[] dp = new int[2];
// dp[0]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点不偷
dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
// dp[1]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点偷
dp[1] = node.val + left[0] + right[0];
return dp;
}
}
| true |
40512_10 | package com.kintexgroup.hkpsi.common.handler;
import com.kintexgroup.hkpsi.common.constants.ResponseCode;
import com.kintexgroup.hkpsi.common.dto.ResponseDTO;
import com.kintexgroup.hkpsi.common.exception.BusinessException;
import com.kintexgroup.hkpsi.common.interfaces.ResponseWrapper;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.MyBatisSystemException;
import org.springframework.context.support.DefaultMessageSourceResolvable;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import java.util.NoSuchElementException;
import java.util.stream.Collectors;
/**
* 异常处理器
*
* @author gradylo
* @author lmao
* @since 2020/8/23 22:18
*/
@ControllerAdvice(annotations = ResponseWrapper.class)
@ResponseBody
@Slf4j
public class ExceptionHandlerAdvice {
/**
* 处理未捕获的Exception
*
* @param e 异常
* @return 统一响应体
*/
@ExceptionHandler(Exception.class)
public ResponseDTO handleException(Exception e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.FAIL.getCode(), ResponseCode.FAIL.getMessage(), null);
}
/**
* 处理未捕获的RuntimeException
*
* @param e 运行时异常
* @return 统一响应体
*/
@ExceptionHandler(RuntimeException.class)
public ResponseDTO handleRuntimeException(RuntimeException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.FAIL.getCode(), ResponseCode.FAIL.getMessage(), null);
}
/**
* 处理数据库异常BaseException
*
* @param e 数据库异常
* @return 统一响应体
*/
@ExceptionHandler(MyBatisSystemException.class)
public ResponseDTO handleMyBatisSystemException(MyBatisSystemException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.DB_SYSTEM_ERROR.getCode(),
ResponseCode.DB_SYSTEM_ERROR.getMessage(), null);
}
/**
* 处理数据库异常BaseException
*
* @param e 数据库异常
* @return 统一响应体
*/
@ExceptionHandler(NullPointerException.class)
public ResponseDTO handleNullPointerException(NullPointerException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.SYSTEM_NULL_POINTER.getCode(),
ResponseCode.SYSTEM_NULL_POINTER.getMessage(), e.getMessage());
}
/**
* NoSuchElementException
*
* @param e NoSuchElementException
* @return 统一响应体
*/
@ExceptionHandler(NoSuchElementException.class)
public ResponseDTO handleMyBatisSystemException(NoSuchElementException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.DB_SELECT_NULL_ERROR.getCode(),
ResponseCode.DB_SELECT_NULL_ERROR.getMessage(), null);
}
/**
* 未处理的数据重复异常DuplicateKeyException
*
* @param e 运行时异常
* @return 统一响应体
*/
@ExceptionHandler(DuplicateKeyException.class)
public ResponseDTO handleDuplicateKeyException(DuplicateKeyException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.DB_DUPLICATE_ERROR.getCode(),
ResponseCode.DB_DUPLICATE_ERROR.getMessage(), null);
}
/**
* 处理不能读取HttpMessage
*
* @param e 异常
* @return 统一响应体
*/
@ExceptionHandler(HttpMessageNotReadableException.class)
public ResponseDTO handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.REQUEST_PARAM_INVALID.getCode(),
ResponseCode.REQUEST_PARAM_INVALID.getMessage(), null);
}
/**
* 处理业务异常BaseException
*
* @param e 业务异常
* @return 统一响应体
*/
@ExceptionHandler(BusinessException.class)
public ResponseDTO handleBaseException(BusinessException e) {
log.error(e.getMessage(), e);
ResponseCode code = e.getCode();
return new ResponseDTO(code.getCode(), code.getMessage(), null);
}
/**
* 统一处理参数校验异常
* <pre>
* 对象参数接收请求体校验不通过会抛出 MethodArgumentNotValidException
* 普通参数校验校验不通过会抛出 ConstraintViolationException
* 必填参数没传校验不通过会抛出 ServletRequestBindingException
* 请求参数绑定到对象上校验不通过会抛出 BindException
* </pre>
*
* @param e 异常父类
* @return 统一响应体
*/
@ExceptionHandler({ConstraintViolationException.class,
MethodArgumentNotValidException.class,
ServletRequestBindingException.class,
BindException.class})
public ResponseDTO handleValidationException(Exception e) {
String logMsg = e.getMessage();
String msg;
if (e instanceof MethodArgumentNotValidException) {
MethodArgumentNotValidException t = (MethodArgumentNotValidException) e;
msg = getBindingResultMsg(t.getBindingResult());
} else if (e instanceof BindException) {
BindException t = (BindException) e;
msg = getBindingResultMsg(t.getBindingResult());
} else if (e instanceof ConstraintViolationException) {
ConstraintViolationException t = (ConstraintViolationException) e;
msg = t.getConstraintViolations().stream()
.map(ConstraintViolation::getMessage)
.collect(Collectors.joining(","));
} else if (e instanceof MissingServletRequestParameterException) {
MissingServletRequestParameterException t = (MissingServletRequestParameterException) e;
msg = t.getParameterName() + " 不能为空";
} else if (e instanceof MissingPathVariableException) {
MissingPathVariableException t = (MissingPathVariableException) e;
msg = t.getVariableName() + " 不能为空";
} else {
// 其他类型的错误当成未知异常处理
return handleException(e);
}
log.error("参数校验不通过, {}, msg: {}", logMsg, msg);
ResponseCode code = ResponseCode.INSERT_PARAM_INVALID;
return new ResponseDTO(code.getCode(), msg, null);
}
private String getBindingResultMsg(BindingResult result) {
return result.getAllErrors().stream().map(DefaultMessageSourceResolvable::getDefaultMessage)
.collect(
Collectors.joining());
}
}
| MINIlaolao/erp-system | src/main/java/com/kintexgroup/hkpsi/common/handler/ExceptionHandlerAdvice.java | 1,679 | // 其他类型的错误当成未知异常处理 | line_comment | zh-cn | package com.kintexgroup.hkpsi.common.handler;
import com.kintexgroup.hkpsi.common.constants.ResponseCode;
import com.kintexgroup.hkpsi.common.dto.ResponseDTO;
import com.kintexgroup.hkpsi.common.exception.BusinessException;
import com.kintexgroup.hkpsi.common.interfaces.ResponseWrapper;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.MyBatisSystemException;
import org.springframework.context.support.DefaultMessageSourceResolvable;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingPathVariableException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import java.util.NoSuchElementException;
import java.util.stream.Collectors;
/**
* 异常处理器
*
* @author gradylo
* @author lmao
* @since 2020/8/23 22:18
*/
@ControllerAdvice(annotations = ResponseWrapper.class)
@ResponseBody
@Slf4j
public class ExceptionHandlerAdvice {
/**
* 处理未捕获的Exception
*
* @param e 异常
* @return 统一响应体
*/
@ExceptionHandler(Exception.class)
public ResponseDTO handleException(Exception e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.FAIL.getCode(), ResponseCode.FAIL.getMessage(), null);
}
/**
* 处理未捕获的RuntimeException
*
* @param e 运行时异常
* @return 统一响应体
*/
@ExceptionHandler(RuntimeException.class)
public ResponseDTO handleRuntimeException(RuntimeException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.FAIL.getCode(), ResponseCode.FAIL.getMessage(), null);
}
/**
* 处理数据库异常BaseException
*
* @param e 数据库异常
* @return 统一响应体
*/
@ExceptionHandler(MyBatisSystemException.class)
public ResponseDTO handleMyBatisSystemException(MyBatisSystemException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.DB_SYSTEM_ERROR.getCode(),
ResponseCode.DB_SYSTEM_ERROR.getMessage(), null);
}
/**
* 处理数据库异常BaseException
*
* @param e 数据库异常
* @return 统一响应体
*/
@ExceptionHandler(NullPointerException.class)
public ResponseDTO handleNullPointerException(NullPointerException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.SYSTEM_NULL_POINTER.getCode(),
ResponseCode.SYSTEM_NULL_POINTER.getMessage(), e.getMessage());
}
/**
* NoSuchElementException
*
* @param e NoSuchElementException
* @return 统一响应体
*/
@ExceptionHandler(NoSuchElementException.class)
public ResponseDTO handleMyBatisSystemException(NoSuchElementException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.DB_SELECT_NULL_ERROR.getCode(),
ResponseCode.DB_SELECT_NULL_ERROR.getMessage(), null);
}
/**
* 未处理的数据重复异常DuplicateKeyException
*
* @param e 运行时异常
* @return 统一响应体
*/
@ExceptionHandler(DuplicateKeyException.class)
public ResponseDTO handleDuplicateKeyException(DuplicateKeyException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.DB_DUPLICATE_ERROR.getCode(),
ResponseCode.DB_DUPLICATE_ERROR.getMessage(), null);
}
/**
* 处理不能读取HttpMessage
*
* @param e 异常
* @return 统一响应体
*/
@ExceptionHandler(HttpMessageNotReadableException.class)
public ResponseDTO handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
log.error(e.getMessage(), e);
return new ResponseDTO(ResponseCode.REQUEST_PARAM_INVALID.getCode(),
ResponseCode.REQUEST_PARAM_INVALID.getMessage(), null);
}
/**
* 处理业务异常BaseException
*
* @param e 业务异常
* @return 统一响应体
*/
@ExceptionHandler(BusinessException.class)
public ResponseDTO handleBaseException(BusinessException e) {
log.error(e.getMessage(), e);
ResponseCode code = e.getCode();
return new ResponseDTO(code.getCode(), code.getMessage(), null);
}
/**
* 统一处理参数校验异常
* <pre>
* 对象参数接收请求体校验不通过会抛出 MethodArgumentNotValidException
* 普通参数校验校验不通过会抛出 ConstraintViolationException
* 必填参数没传校验不通过会抛出 ServletRequestBindingException
* 请求参数绑定到对象上校验不通过会抛出 BindException
* </pre>
*
* @param e 异常父类
* @return 统一响应体
*/
@ExceptionHandler({ConstraintViolationException.class,
MethodArgumentNotValidException.class,
ServletRequestBindingException.class,
BindException.class})
public ResponseDTO handleValidationException(Exception e) {
String logMsg = e.getMessage();
String msg;
if (e instanceof MethodArgumentNotValidException) {
MethodArgumentNotValidException t = (MethodArgumentNotValidException) e;
msg = getBindingResultMsg(t.getBindingResult());
} else if (e instanceof BindException) {
BindException t = (BindException) e;
msg = getBindingResultMsg(t.getBindingResult());
} else if (e instanceof ConstraintViolationException) {
ConstraintViolationException t = (ConstraintViolationException) e;
msg = t.getConstraintViolations().stream()
.map(ConstraintViolation::getMessage)
.collect(Collectors.joining(","));
} else if (e instanceof MissingServletRequestParameterException) {
MissingServletRequestParameterException t = (MissingServletRequestParameterException) e;
msg = t.getParameterName() + " 不能为空";
} else if (e instanceof MissingPathVariableException) {
MissingPathVariableException t = (MissingPathVariableException) e;
msg = t.getVariableName() + " 不能为空";
} else {
// 其他 <SUF>
return handleException(e);
}
log.error("参数校验不通过, {}, msg: {}", logMsg, msg);
ResponseCode code = ResponseCode.INSERT_PARAM_INVALID;
return new ResponseDTO(code.getCode(), msg, null);
}
private String getBindingResultMsg(BindingResult result) {
return result.getAllErrors().stream().map(DefaultMessageSourceResolvable::getDefaultMessage)
.collect(
Collectors.joining());
}
}
| true |
43772_3 | package com.hlsp.video.model;
import com.hlsp.video.bean.AuthorInfoResponse;
import com.hlsp.video.bean.AuthorVideoResponse;
import com.hlsp.video.bean.LoginResult;
import com.hlsp.video.bean.data.ChannelListData;
import com.hlsp.video.bean.data.VideoListData;
import com.hlsp.video.bean.data.VideoUrlData;
import com.hlsp.video.model.main.MainInfo;
import java.util.List;
import java.util.Map;
import cn.share.jack.cyghttp.BaseResponse;
import io.reactivex.Observable;
import okhttp3.RequestBody;
import retrofit2.http.Body;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Query;
/**
* Created by jack on 2017/6/13
*/
public interface CygApi {
@FormUrlEncoded
@POST("MainServlet")
Observable<BaseResponse<List<MainInfo>>> getArticle(@FieldMap Map<String, String> params);
/**
* 获取频道列表
*/
@POST("v1/search/channelOf360")
Observable<BaseResponse<ChannelListData>> getChannel(@Body RequestBody body);
/**
* 获取频道的视频列表
*/
@POST("v1/search/videoListOf360")
Observable<BaseResponse<VideoListData>> getVideoList(@Body RequestBody body);
/**
* 解密视频
*/
@POST("v1/search/videoUrlOf360")
Observable<BaseResponse<VideoUrlData>> getVideoUrl(@Body RequestBody body);
/**
* 获取作者信息
*/
@POST("v1/search/getLocalAuthor")
Observable<BaseResponse<AuthorInfoResponse>> getAuthorInfo(@Body RequestBody body);
/**
* 获取作者作品
*/
@POST("v1/search/getLocalVideo")
Observable<BaseResponse<AuthorVideoResponse>> getAuthorVideo(@Body RequestBody body);
/**
* 邮箱登录
*/
@POST("v2/login/")
Observable<BaseResponse<LoginResult>> login(@Body RequestBody body);
/**
* 版本更新
*/
@GET("check/")
Observable<BaseResponse<LoginResult>> updateVersion(@Query("type") String type);
} | MIkeeJY/honglou | app/src/main/java/com/hlsp/video/model/CygApi.java | 578 | /**
* 解密视频
*/ | block_comment | zh-cn | package com.hlsp.video.model;
import com.hlsp.video.bean.AuthorInfoResponse;
import com.hlsp.video.bean.AuthorVideoResponse;
import com.hlsp.video.bean.LoginResult;
import com.hlsp.video.bean.data.ChannelListData;
import com.hlsp.video.bean.data.VideoListData;
import com.hlsp.video.bean.data.VideoUrlData;
import com.hlsp.video.model.main.MainInfo;
import java.util.List;
import java.util.Map;
import cn.share.jack.cyghttp.BaseResponse;
import io.reactivex.Observable;
import okhttp3.RequestBody;
import retrofit2.http.Body;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Query;
/**
* Created by jack on 2017/6/13
*/
public interface CygApi {
@FormUrlEncoded
@POST("MainServlet")
Observable<BaseResponse<List<MainInfo>>> getArticle(@FieldMap Map<String, String> params);
/**
* 获取频道列表
*/
@POST("v1/search/channelOf360")
Observable<BaseResponse<ChannelListData>> getChannel(@Body RequestBody body);
/**
* 获取频道的视频列表
*/
@POST("v1/search/videoListOf360")
Observable<BaseResponse<VideoListData>> getVideoList(@Body RequestBody body);
/**
* 解密视 <SUF>*/
@POST("v1/search/videoUrlOf360")
Observable<BaseResponse<VideoUrlData>> getVideoUrl(@Body RequestBody body);
/**
* 获取作者信息
*/
@POST("v1/search/getLocalAuthor")
Observable<BaseResponse<AuthorInfoResponse>> getAuthorInfo(@Body RequestBody body);
/**
* 获取作者作品
*/
@POST("v1/search/getLocalVideo")
Observable<BaseResponse<AuthorVideoResponse>> getAuthorVideo(@Body RequestBody body);
/**
* 邮箱登录
*/
@POST("v2/login/")
Observable<BaseResponse<LoginResult>> login(@Body RequestBody body);
/**
* 版本更新
*/
@GET("check/")
Observable<BaseResponse<LoginResult>> updateVersion(@Query("type") String type);
} | false |
58652_35 | package com.lzf.attendancesystem.activity;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.hardware.Camera;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.arcsoft.face.AgeInfo;
import com.arcsoft.face.ErrorInfo;
import com.arcsoft.face.FaceEngine;
import com.arcsoft.face.FaceFeature;
import com.arcsoft.face.FaceInfo;
import com.arcsoft.face.FaceSimilar;
import com.arcsoft.face.GenderInfo;
import com.arcsoft.face.LivenessInfo;
import com.arcsoft.face.enums.DetectFaceOrientPriority;
import com.arcsoft.face.enums.DetectMode;
import com.lzf.attendancesystem.R;
import com.lzf.attendancesystem.ZffApplication;
import com.lzf.attendancesystem.bean.Attendance;
import com.lzf.attendancesystem.bean.AttendanceDao;
import com.lzf.attendancesystem.bean.Staff;
import com.lzf.attendancesystem.bean.StaffDao;
import org.greenrobot.greendao.query.QueryBuilder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.TimeZone;
public class SignInActivity extends AppCompatActivity {
private int currentCameraID; //当前摄像头ID
private int frontCameraId; //前置摄像头ID
private int frontCameraDegrees; //前置摄像头要旋转的度数
private int backCameraId; //后置摄像头ID
private int backCameraDegrees; //后置摄像头要旋转的度数
private Camera camera; //照相机（硬件）对象
private MediaRecorder mediaRecorder; //录制视频
private SurfaceView surfaceView; //预览视图
private TextView age; //年龄显示
private int ageValue = 0; //年龄检测结果
private TextView gender; //性别显示
private TextView liveness; //活体检测显示
private String livenessInfo = ""; //活体检测结果
private ImageView signInSuccess;
private LinearLayout signInSuccessLinear;
private TextView staffId;
private TextView staffName;
private TextView signInTime;
private TextView signInSuccessT;
private List<Staff> staffList = ZffApplication.getDaoSession(this).getStaffDao().queryBuilder().orderAsc(StaffDao.Properties.StaffId).list();
private double latitude;
private double longitude;
private AttendanceDao attendanceDao = ZffApplication.getDaoSession(this).getAttendanceDao();
private long today = System.currentTimeMillis() / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();//今天零点零分零秒的毫秒数
private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
private Camera.PreviewCallback previewCallback = new Camera.PreviewCallback() {
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
/**
* data - 输入的图像数据
* width - 图像的宽度
* height - 图像的高度
* format - 图像的颜色空间格式，支持NV21(CP_PAF_NV21)、BGR24(CP_PAF_BGR24)
* faceInfoList - 人脸列表，传入后赋值
*/
List<FaceInfo> faceInfos = new ArrayList<FaceInfo>();
Camera.Size previewSize = camera.getParameters().getPreviewSize();
if (ZffApplication.getFaceEngine().detectFaces(data, previewSize.width, previewSize.height, FaceEngine.CP_PAF_NV21, faceInfos) == ErrorInfo.MOK && faceInfos.size() > 0) {
for (FaceInfo faceInfo : faceInfos) {
FaceFeature currentFaceFeature = new FaceFeature();
if (ZffApplication.getFaceEngine().extractFaceFeature(data, previewSize.width, previewSize.height, FaceEngine.CP_PAF_NV21, faceInfo, currentFaceFeature) == ErrorInfo.MOK) {
FaceSimilar faceSimilar = new FaceSimilar();
for (Staff staff : staffList) {
FaceFeature compareFaceFeature = new FaceFeature();
compareFaceFeature.setFeatureData(staff.getStaffFaceOneFeatureData());
if (ZffApplication.getFaceEngine().compareFaceFeature(currentFaceFeature, compareFaceFeature, faceSimilar) == ErrorInfo.MOK) {
// Log.v("faceSimilar.getScore()", faceSimilar.getScore() + "");
if (faceSimilar.getScore() >= 0.65f) { //签到成功
signInSuccess(staff);
}
}
compareFaceFeature.setFeatureData(staff.getStaffFaceTwoFeatureData());
if (ZffApplication.getFaceEngine().compareFaceFeature(currentFaceFeature, compareFaceFeature, faceSimilar) == ErrorInfo.MOK) {
// Log.v("faceSimilar.getScore()", faceSimilar.getScore() + "");
if (faceSimilar.getScore() > 0.65f) { //签到成功
signInSuccess(staff);
}
}
compareFaceFeature.setFeatureData(staff.getStaffFaceThreeFeatureData());
if (ZffApplication.getFaceEngine().compareFaceFeature(currentFaceFeature, compareFaceFeature, faceSimilar) == ErrorInfo.MOK) {
// Log.v("faceSimilar.getScore()", faceSimilar.getScore() + "");
if (faceSimilar.getScore() > 0.65f) { //签到成功
signInSuccess(staff);
}
}
}
}
}
int faceEndineProcess = ZffApplication.getFaceEngine().process(data, previewSize.width, previewSize.height, FaceEngine.CP_PAF_NV21, faceInfos, FaceEngine.ASF_AGE | FaceEngine.ASF_GENDER | FaceEngine.ASF_FACE3DANGLE | FaceEngine.ASF_LIVENESS);
if (faceEndineProcess == ErrorInfo.MOK) {
List<AgeInfo> ageInfos = new ArrayList<AgeInfo>();
int faceEndineAge = ZffApplication.getFaceEngine().getAge(ageInfos);
if (faceEndineAge == ErrorInfo.MOK) {
for (AgeInfo ageInfo : ageInfos) {
ageValue = ageInfo.getAge();
if (ageInfo.getAge() == AgeInfo.UNKNOWN_AGE) {
age.setText("");
} else if (ageValue > -1 && ageValue < 45) {
age.setText(ageValue + "岁");
} else {
age.setText("");
}
}
}
List<GenderInfo> genderInfos = new ArrayList<GenderInfo>();
int faceEndineGender = ZffApplication.getFaceEngine().getGender(genderInfos);
if (faceEndineGender == ErrorInfo.MOK) {
for (GenderInfo genderInfo : genderInfos) {
if (genderInfo.getGender() == GenderInfo.FEMALE) {
if (ageValue < 11) {
gender.setText("小可爱");
} else if (ageValue >= 11 && ageValue < 15) {
gender.setText("豆蔻年华");
} else if (ageValue >= 15 && ageValue < 25) {
gender.setText("美少女");
} else if (ageValue >= 25 && ageValue < 30) {
gender.setText("花房姑娘");
} else if (ageValue >= 30 && ageValue < 35) {
gender.setText("仙女");
} else if (ageValue >= 35 && ageValue < 45) {
gender.setText("御姐"); //半老徐娘
} else {
gender.setText("");
}
// else if (ageValue >= 45 && ageValue < 60) {
// gender.setText("阿姨，求介绍对象！");
// } else if (ageValue >= 60) {
// gender.setText("奶奶，你保养的真好，简直就是鹤发童颜啊！");
// }
} else if (genderInfo.getGender() == GenderInfo.MALE) {
if (ageValue < 11) {
gender.setText("少年");
} else if (ageValue >= 11 && ageValue < 15) {
gender.setText("帅小伙");
} else if (ageValue >= 15 && ageValue < 25) {
gender.setText("小鲜肉！");
} else if (ageValue >= 25 && ageValue < 30) {
gender.setText("哇！帅哥！");
} else if (ageValue >= 30 && ageValue < 40) {
gender.setText("三十而立，四十不惑。");
} else if (ageValue >= 40 && ageValue < 45) {
gender.setText("身体困了吧？大叔！"); //半老徐娘
} else {
gender.setText("");
}
// else if (ageValue >= 45 && ageValue < 60) {
// gender.setText("知天命，入花甲。");
// } else if (ageValue >= 60 && ageValue < 75) {
// gender.setText("爷爷，一看你就是老而益壮！");
// } else if (ageValue >= 75) {
// gender.setText("爷爷，你是否已饱经风霜？"); //饱经风霜//老气横秋//老而益壮
// }
} else {
gender.setText("");
}
}
}
List<LivenessInfo> livenessInfos = new ArrayList<LivenessInfo>();
int faceEndineLiveness = ZffApplication.getFaceEngine().getLiveness(livenessInfos);
if (faceEndineLiveness == ErrorInfo.MOK) {
for (LivenessInfo livenessInfoTemp : livenessInfos) {
if (livenessInfoTemp.getLiveness() == LivenessInfo.ALIVE) {
// liveness.setText("嗯，一看你就是能量慢慢，充满活力。");
livenessInfo = "ALIVE";
liveness.setText("");
} else if (livenessInfoTemp.getLiveness() == LivenessInfo.NOT_ALIVE) {
// liveness.setText("一动不动是王八！");
if ("NOT_ALIVE".equals(livenessInfo)) {
liveness.setText("照片不能代替人脸来签到哦！");
}
livenessInfo = "NOT_ALIVE";
} else if (livenessInfoTemp.getLiveness() == LivenessInfo.FACE_NUM_MORE_THAN_ONE) {
if ("FACE_NUM_MORE_THAN_ONE".equals(livenessInfo)) {
liveness.setText("这么多人，一个一个来好吗？");
}
livenessInfo = "FACE_NUM_MORE_THAN_ONE";
} else {
livenessInfo = "UNKNOW";
liveness.setText("");
}
}
}
}
}
}
};
private SurfaceHolder.Callback surfaceHolderCallback = new SurfaceHolder.Callback() {
@Override
public void surfaceCreated(SurfaceHolder holder) { //开始预览
try {
if (camera == null) {
Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
for (int cameraIndex = 0; cameraIndex < Camera.getNumberOfCameras(); cameraIndex++) {
Camera.getCameraInfo(cameraIndex, cameraInfo);
int rotation = SignInActivity.this.getWindowManager().getDefaultDisplay().getRotation();
if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
frontCameraId = cameraIndex;
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
frontCameraDegrees = (cameraInfo.orientation + degrees) % 360;
frontCameraDegrees = (360 - frontCameraDegrees) % 360; // compensate the mirror
// camera = Camera.open(frontCameraId); //前置摄像头
// camera.setDisplayOrientation(270); //让相机旋转270度
} else if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
backCameraId = cameraIndex;
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
backCameraDegrees = (cameraInfo.orientation - degrees + 360) % 360;
// camera = Camera.open(backCameraId); //后置摄像头
// camera.setDisplayOrientation(90); //让相机旋转90度
}
}
// currentCameraID = backCameraId;
currentCameraID = frontCameraId;
camera = Camera.open(currentCameraID);
camera.setDisplayOrientation(backCameraDegrees); //让相机旋转90度
}
camera.setPreviewDisplay(surfaceView.getHolder());
camera.setPreviewCallback(previewCallback);
camera.startPreview();
// if (camera != null) {
// camera.unlock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
// if (mediaRecorder == null) {
// mediaRecorder = new MediaRecorder();
// }
// mediaRecorder.setCamera(camera);
// mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER); //设置音频源
// mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); //设置视频源
// mediaRecorder.setProfile(CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_HIGH));
// mediaRecorder.setOutputFile(FileUtil.getNewFile(SignInActivity.this, "video", "SignInVideo.mp4"));
// mediaRecorder.setPreviewDisplay(surfaceView.getHolder().getSurface());
// mediaRecorder.prepare();
// mediaRecorder.start();
// }
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
try {
// if (mediaRecorder != null) {
// mediaRecorder.stop();
// mediaRecorder.reset();
// mediaRecorder.release();
// mediaRecorder = null;
// }
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.stopPreview();
camera.release();
camera = null;
}
} catch (Exception e) {
e.printStackTrace();
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sign_in);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
Intent intent = getIntent();
latitude = intent.getDoubleExtra("latitude", 0);
longitude = intent.getDoubleExtra("longitude", 0);
if (checkCamera() && faceEngineIsInit()) {
age = findViewById(R.id.age);
gender = findViewById(R.id.gender);
liveness = findViewById(R.id.liveness);
surfaceView = findViewById(R.id.surfaceView);
surfaceView.getHolder().addCallback(surfaceHolderCallback);
signInSuccess = findViewById(R.id.signInSuccess);
signInSuccessLinear = findViewById(R.id.signInSuccessLinear);
staffId = findViewById(R.id.staffId);
staffName = findViewById(R.id.staffName);
signInTime = findViewById(R.id.signInTime);
signInSuccessT = findViewById(R.id.signInSuccessT);
} else {
Toast.makeText(this, "抱歉，摄像头不可用", Toast.LENGTH_SHORT).show();
finish();
}
}
public void onClick(View view) {
switch (view.getId()) {
case R.id.autorenew:
try {
age.setText("");
gender.setText("");
liveness.setText("");
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.stopPreview();
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.release();
camera = null;
}
if (currentCameraID == frontCameraId) {
currentCameraID = backCameraId;
camera = Camera.open(currentCameraID);
camera.setDisplayOrientation(backCameraDegrees); //让相机旋转一定度数
camera.setPreviewDisplay(surfaceView.getHolder());
camera.setPreviewCallback(previewCallback);
camera.startPreview();
} else if (currentCameraID == backCameraId) {
currentCameraID = frontCameraId;
camera = Camera.open(currentCameraID);
camera.setDisplayOrientation(frontCameraDegrees); //让相机旋转一定度数
camera.setPreviewDisplay(surfaceView.getHolder());
camera.setPreviewCallback(previewCallback);
camera.startPreview();
}
} catch (Exception e) {
e.printStackTrace();
}
break;
default:
break;
}
}
/**
* 摄像头是否存在
*
* @return true：摄像头存在
*/
private boolean checkCamera() {
return this.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
/**
* context - 上下文对象
* detectMode - 检测模式，支持视频模式(ASF_DETECT_MODE_VIDEO)和图像模式(ASF_DETECT_MODE_IMAGE)
* detectFaceOrientPriority - 人脸检测方向的优先级，支持仅0度(ASF_OP_0_ONLY)，仅90度(ASF_OP_90_ONLY)，仅180度(ASF_OP_180_ONLY)，仅270度(ASF_OP_270_ONLY)，多方向检测(ASF_OP_0_HIGHER_EXT)
* detectFaceScaleVal - 人脸相对于所在图片的长边的占比，在视频模式(ASF_DETECT_MODE_VIDEO)下有效值范围[2，16]，在图像模式(ASF_DETECT_MODE_IMAGE)下有效值范围[2，32]
* detectFaceMaxNum - 引擎最多能检测出的人脸数，有效值范围[1,50]
* combinedMask - 初始化引擎功能组合，可以是ASF_NONE、ASF_FACE_DETECT、ASF_FACE_RECOGNITION、ASF_AGE、ASF_GENDER、ASF_FACE3DANGLE、ASF_LIVENESS中的单个或者多个，用 | 运算符拼接
*
* @return FaceEngine是否初始化成功
*/
private boolean faceEngineIsInit() {
int faceEngineInit = ZffApplication.getFaceEngine().init(this, DetectMode.ASF_DETECT_MODE_VIDEO, DetectFaceOrientPriority.ASF_OP_ALL_OUT, 16, 1, FaceEngine.ASF_FACE_DETECT | FaceEngine.ASF_FACE_RECOGNITION | FaceEngine.ASF_AGE | FaceEngine.ASF_GENDER | FaceEngine.ASF_FACE3DANGLE | FaceEngine.ASF_LIVENESS | FaceEngine.ASF_IR_LIVENESS);
Log.v("faceEngineInit", faceEngineInit + "");
return faceEngineInit == ErrorInfo.MOK;
}
private synchronized void signInSuccess(Staff staff) {
try {
if ("ALIVE".equals(livenessInfo)) {
QueryBuilder<Attendance> queryBuilder = attendanceDao.queryBuilder();
queryBuilder.where(AttendanceDao.Properties.StaffId.eq(staff.getStaffId()), AttendanceDao.Properties.StaffName.eq(staff.getStaffName()), AttendanceDao.Properties.StaffDepartment.eq(staff.getStaffDepartment()), queryBuilder.or(AttendanceDao.Properties.SignInTime.gt(today), AttendanceDao.Properties.SignOutTime.gt(today)));
List<Attendance> attendances = queryBuilder.list();
if (attendances != null && attendances.size() > 0) {
Attendance attendance = attendances.get(0);
if (attendances.get(0).getSignInTime() > 1000) {
signInSuccessUI(attendance, "你已经签到过了");
} else {
attendance.setSignInTime(System.currentTimeMillis());
attendance.setSignInLatitude(latitude);
attendance.setSignInLongitude(longitude);
attendanceDao.update(attendance);
signInSuccessUI(attendance, "恭喜你，上班签到成功。");
}
} else {
Cursor cursor = null;
long attendanceId = 0;
try {
cursor = ZffApplication.getDaoSession(this).getDatabase().rawQuery("select max(ATTENDANCE_ID) MAX_ATTENDANCE_ID from ATTENDANCE", null);
while (cursor.moveToNext()) {
attendanceId = cursor.getLong(cursor.getColumnIndex("MAX_ATTENDANCE_ID")) + 1;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (cursor != null) {
cursor.close();
}
}
Attendance attendance = new Attendance(attendanceId, staff.getStaffId(), staff.getStaffName(), staff.getStaffDepartment(), System.currentTimeMillis(), latitude, longitude,
0L, 0, 0);
attendanceDao.insert(attendance);
signInSuccessUI(attendance, "恭喜你，上班签到成功。");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private synchronized void signInSuccessUI(final Attendance attendance, final String result) {
// if (!"".equals(age.getText().toString()) && !"".equals(gender.getText().toString()) && !"".equals(liveness.getText().toString())) {
// signInSuccess.setVisibility(View.VISIBLE);
// 工号……姓名……时间……签到类型
signInSuccessT.setText(result);
staffId.setText(attendance.getStaffId() + "");
staffName.setText(attendance.getStaffName());
signInTime.setText(simpleDateFormat.format(attendance.getSignInTime()));
new Thread() {
@Override
public void run() {
super.run();
try {
runOnUiThread(new Runnable() {
@Override
public void run() {
signInSuccessLinear.setVisibility(View.VISIBLE);
}
});
Thread.sleep(2000);
runOnUiThread(new Runnable() {
@Override
public void run() {
signInSuccessLinear.setVisibility(View.GONE);
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
// }
}
@Override
protected void onDestroy() {
super.onDestroy();
try {
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.stopPreview();
camera.release();
camera = null;
}
//调用FaceEngine的unInit方法销毁引擎。在init成功后如不unInit会导致内存泄漏。
ZffApplication.getFaceEngine().unInit();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onBackPressed() {
super.onBackPressed();
try {
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.stopPreview();
camera.release();
camera = null;
}
//调用FaceEngine的unInit方法销毁引擎。在init成功后如不unInit会导致内存泄漏。
ZffApplication.getFaceEngine().unInit();
finish();
} catch (Exception e) {
e.printStackTrace();
}
}
}
| MJCoderMJCoder/AttendanceSystem-- | app/src/main/java/com/lzf/attendancesystem/activity/SignInActivity.java | 6,113 | //开始预览 | line_comment | zh-cn | package com.lzf.attendancesystem.activity;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.hardware.Camera;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
import com.arcsoft.face.AgeInfo;
import com.arcsoft.face.ErrorInfo;
import com.arcsoft.face.FaceEngine;
import com.arcsoft.face.FaceFeature;
import com.arcsoft.face.FaceInfo;
import com.arcsoft.face.FaceSimilar;
import com.arcsoft.face.GenderInfo;
import com.arcsoft.face.LivenessInfo;
import com.arcsoft.face.enums.DetectFaceOrientPriority;
import com.arcsoft.face.enums.DetectMode;
import com.lzf.attendancesystem.R;
import com.lzf.attendancesystem.ZffApplication;
import com.lzf.attendancesystem.bean.Attendance;
import com.lzf.attendancesystem.bean.AttendanceDao;
import com.lzf.attendancesystem.bean.Staff;
import com.lzf.attendancesystem.bean.StaffDao;
import org.greenrobot.greendao.query.QueryBuilder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.TimeZone;
public class SignInActivity extends AppCompatActivity {
private int currentCameraID; //当前摄像头ID
private int frontCameraId; //前置摄像头ID
private int frontCameraDegrees; //前置摄像头要旋转的度数
private int backCameraId; //后置摄像头ID
private int backCameraDegrees; //后置摄像头要旋转的度数
private Camera camera; //照相机（硬件）对象
private MediaRecorder mediaRecorder; //录制视频
private SurfaceView surfaceView; //预览视图
private TextView age; //年龄显示
private int ageValue = 0; //年龄检测结果
private TextView gender; //性别显示
private TextView liveness; //活体检测显示
private String livenessInfo = ""; //活体检测结果
private ImageView signInSuccess;
private LinearLayout signInSuccessLinear;
private TextView staffId;
private TextView staffName;
private TextView signInTime;
private TextView signInSuccessT;
private List<Staff> staffList = ZffApplication.getDaoSession(this).getStaffDao().queryBuilder().orderAsc(StaffDao.Properties.StaffId).list();
private double latitude;
private double longitude;
private AttendanceDao attendanceDao = ZffApplication.getDaoSession(this).getAttendanceDao();
private long today = System.currentTimeMillis() / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();//今天零点零分零秒的毫秒数
private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
private Camera.PreviewCallback previewCallback = new Camera.PreviewCallback() {
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
/**
* data - 输入的图像数据
* width - 图像的宽度
* height - 图像的高度
* format - 图像的颜色空间格式，支持NV21(CP_PAF_NV21)、BGR24(CP_PAF_BGR24)
* faceInfoList - 人脸列表，传入后赋值
*/
List<FaceInfo> faceInfos = new ArrayList<FaceInfo>();
Camera.Size previewSize = camera.getParameters().getPreviewSize();
if (ZffApplication.getFaceEngine().detectFaces(data, previewSize.width, previewSize.height, FaceEngine.CP_PAF_NV21, faceInfos) == ErrorInfo.MOK && faceInfos.size() > 0) {
for (FaceInfo faceInfo : faceInfos) {
FaceFeature currentFaceFeature = new FaceFeature();
if (ZffApplication.getFaceEngine().extractFaceFeature(data, previewSize.width, previewSize.height, FaceEngine.CP_PAF_NV21, faceInfo, currentFaceFeature) == ErrorInfo.MOK) {
FaceSimilar faceSimilar = new FaceSimilar();
for (Staff staff : staffList) {
FaceFeature compareFaceFeature = new FaceFeature();
compareFaceFeature.setFeatureData(staff.getStaffFaceOneFeatureData());
if (ZffApplication.getFaceEngine().compareFaceFeature(currentFaceFeature, compareFaceFeature, faceSimilar) == ErrorInfo.MOK) {
// Log.v("faceSimilar.getScore()", faceSimilar.getScore() + "");
if (faceSimilar.getScore() >= 0.65f) { //签到成功
signInSuccess(staff);
}
}
compareFaceFeature.setFeatureData(staff.getStaffFaceTwoFeatureData());
if (ZffApplication.getFaceEngine().compareFaceFeature(currentFaceFeature, compareFaceFeature, faceSimilar) == ErrorInfo.MOK) {
// Log.v("faceSimilar.getScore()", faceSimilar.getScore() + "");
if (faceSimilar.getScore() > 0.65f) { //签到成功
signInSuccess(staff);
}
}
compareFaceFeature.setFeatureData(staff.getStaffFaceThreeFeatureData());
if (ZffApplication.getFaceEngine().compareFaceFeature(currentFaceFeature, compareFaceFeature, faceSimilar) == ErrorInfo.MOK) {
// Log.v("faceSimilar.getScore()", faceSimilar.getScore() + "");
if (faceSimilar.getScore() > 0.65f) { //签到成功
signInSuccess(staff);
}
}
}
}
}
int faceEndineProcess = ZffApplication.getFaceEngine().process(data, previewSize.width, previewSize.height, FaceEngine.CP_PAF_NV21, faceInfos, FaceEngine.ASF_AGE | FaceEngine.ASF_GENDER | FaceEngine.ASF_FACE3DANGLE | FaceEngine.ASF_LIVENESS);
if (faceEndineProcess == ErrorInfo.MOK) {
List<AgeInfo> ageInfos = new ArrayList<AgeInfo>();
int faceEndineAge = ZffApplication.getFaceEngine().getAge(ageInfos);
if (faceEndineAge == ErrorInfo.MOK) {
for (AgeInfo ageInfo : ageInfos) {
ageValue = ageInfo.getAge();
if (ageInfo.getAge() == AgeInfo.UNKNOWN_AGE) {
age.setText("");
} else if (ageValue > -1 && ageValue < 45) {
age.setText(ageValue + "岁");
} else {
age.setText("");
}
}
}
List<GenderInfo> genderInfos = new ArrayList<GenderInfo>();
int faceEndineGender = ZffApplication.getFaceEngine().getGender(genderInfos);
if (faceEndineGender == ErrorInfo.MOK) {
for (GenderInfo genderInfo : genderInfos) {
if (genderInfo.getGender() == GenderInfo.FEMALE) {
if (ageValue < 11) {
gender.setText("小可爱");
} else if (ageValue >= 11 && ageValue < 15) {
gender.setText("豆蔻年华");
} else if (ageValue >= 15 && ageValue < 25) {
gender.setText("美少女");
} else if (ageValue >= 25 && ageValue < 30) {
gender.setText("花房姑娘");
} else if (ageValue >= 30 && ageValue < 35) {
gender.setText("仙女");
} else if (ageValue >= 35 && ageValue < 45) {
gender.setText("御姐"); //半老徐娘
} else {
gender.setText("");
}
// else if (ageValue >= 45 && ageValue < 60) {
// gender.setText("阿姨，求介绍对象！");
// } else if (ageValue >= 60) {
// gender.setText("奶奶，你保养的真好，简直就是鹤发童颜啊！");
// }
} else if (genderInfo.getGender() == GenderInfo.MALE) {
if (ageValue < 11) {
gender.setText("少年");
} else if (ageValue >= 11 && ageValue < 15) {
gender.setText("帅小伙");
} else if (ageValue >= 15 && ageValue < 25) {
gender.setText("小鲜肉！");
} else if (ageValue >= 25 && ageValue < 30) {
gender.setText("哇！帅哥！");
} else if (ageValue >= 30 && ageValue < 40) {
gender.setText("三十而立，四十不惑。");
} else if (ageValue >= 40 && ageValue < 45) {
gender.setText("身体困了吧？大叔！"); //半老徐娘
} else {
gender.setText("");
}
// else if (ageValue >= 45 && ageValue < 60) {
// gender.setText("知天命，入花甲。");
// } else if (ageValue >= 60 && ageValue < 75) {
// gender.setText("爷爷，一看你就是老而益壮！");
// } else if (ageValue >= 75) {
// gender.setText("爷爷，你是否已饱经风霜？"); //饱经风霜//老气横秋//老而益壮
// }
} else {
gender.setText("");
}
}
}
List<LivenessInfo> livenessInfos = new ArrayList<LivenessInfo>();
int faceEndineLiveness = ZffApplication.getFaceEngine().getLiveness(livenessInfos);
if (faceEndineLiveness == ErrorInfo.MOK) {
for (LivenessInfo livenessInfoTemp : livenessInfos) {
if (livenessInfoTemp.getLiveness() == LivenessInfo.ALIVE) {
// liveness.setText("嗯，一看你就是能量慢慢，充满活力。");
livenessInfo = "ALIVE";
liveness.setText("");
} else if (livenessInfoTemp.getLiveness() == LivenessInfo.NOT_ALIVE) {
// liveness.setText("一动不动是王八！");
if ("NOT_ALIVE".equals(livenessInfo)) {
liveness.setText("照片不能代替人脸来签到哦！");
}
livenessInfo = "NOT_ALIVE";
} else if (livenessInfoTemp.getLiveness() == LivenessInfo.FACE_NUM_MORE_THAN_ONE) {
if ("FACE_NUM_MORE_THAN_ONE".equals(livenessInfo)) {
liveness.setText("这么多人，一个一个来好吗？");
}
livenessInfo = "FACE_NUM_MORE_THAN_ONE";
} else {
livenessInfo = "UNKNOW";
liveness.setText("");
}
}
}
}
}
}
};
private SurfaceHolder.Callback surfaceHolderCallback = new SurfaceHolder.Callback() {
@Override
public void surfaceCreated(SurfaceHolder holder) { //开始 <SUF>
try {
if (camera == null) {
Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
for (int cameraIndex = 0; cameraIndex < Camera.getNumberOfCameras(); cameraIndex++) {
Camera.getCameraInfo(cameraIndex, cameraInfo);
int rotation = SignInActivity.this.getWindowManager().getDefaultDisplay().getRotation();
if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
frontCameraId = cameraIndex;
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
frontCameraDegrees = (cameraInfo.orientation + degrees) % 360;
frontCameraDegrees = (360 - frontCameraDegrees) % 360; // compensate the mirror
// camera = Camera.open(frontCameraId); //前置摄像头
// camera.setDisplayOrientation(270); //让相机旋转270度
} else if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
backCameraId = cameraIndex;
int degrees = 0;
switch (rotation) {
case Surface.ROTATION_0:
degrees = 0;
break;
case Surface.ROTATION_90:
degrees = 90;
break;
case Surface.ROTATION_180:
degrees = 180;
break;
case Surface.ROTATION_270:
degrees = 270;
break;
}
backCameraDegrees = (cameraInfo.orientation - degrees + 360) % 360;
// camera = Camera.open(backCameraId); //后置摄像头
// camera.setDisplayOrientation(90); //让相机旋转90度
}
}
// currentCameraID = backCameraId;
currentCameraID = frontCameraId;
camera = Camera.open(currentCameraID);
camera.setDisplayOrientation(backCameraDegrees); //让相机旋转90度
}
camera.setPreviewDisplay(surfaceView.getHolder());
camera.setPreviewCallback(previewCallback);
camera.startPreview();
// if (camera != null) {
// camera.unlock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
// if (mediaRecorder == null) {
// mediaRecorder = new MediaRecorder();
// }
// mediaRecorder.setCamera(camera);
// mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER); //设置音频源
// mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); //设置视频源
// mediaRecorder.setProfile(CamcorderProfile.get(cameraId, CamcorderProfile.QUALITY_HIGH));
// mediaRecorder.setOutputFile(FileUtil.getNewFile(SignInActivity.this, "video", "SignInVideo.mp4"));
// mediaRecorder.setPreviewDisplay(surfaceView.getHolder().getSurface());
// mediaRecorder.prepare();
// mediaRecorder.start();
// }
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
try {
// if (mediaRecorder != null) {
// mediaRecorder.stop();
// mediaRecorder.reset();
// mediaRecorder.release();
// mediaRecorder = null;
// }
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.stopPreview();
camera.release();
camera = null;
}
} catch (Exception e) {
e.printStackTrace();
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sign_in);
getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
Intent intent = getIntent();
latitude = intent.getDoubleExtra("latitude", 0);
longitude = intent.getDoubleExtra("longitude", 0);
if (checkCamera() && faceEngineIsInit()) {
age = findViewById(R.id.age);
gender = findViewById(R.id.gender);
liveness = findViewById(R.id.liveness);
surfaceView = findViewById(R.id.surfaceView);
surfaceView.getHolder().addCallback(surfaceHolderCallback);
signInSuccess = findViewById(R.id.signInSuccess);
signInSuccessLinear = findViewById(R.id.signInSuccessLinear);
staffId = findViewById(R.id.staffId);
staffName = findViewById(R.id.staffName);
signInTime = findViewById(R.id.signInTime);
signInSuccessT = findViewById(R.id.signInSuccessT);
} else {
Toast.makeText(this, "抱歉，摄像头不可用", Toast.LENGTH_SHORT).show();
finish();
}
}
public void onClick(View view) {
switch (view.getId()) {
case R.id.autorenew:
try {
age.setText("");
gender.setText("");
liveness.setText("");
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.stopPreview();
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.release();
camera = null;
}
if (currentCameraID == frontCameraId) {
currentCameraID = backCameraId;
camera = Camera.open(currentCameraID);
camera.setDisplayOrientation(backCameraDegrees); //让相机旋转一定度数
camera.setPreviewDisplay(surfaceView.getHolder());
camera.setPreviewCallback(previewCallback);
camera.startPreview();
} else if (currentCameraID == backCameraId) {
currentCameraID = frontCameraId;
camera = Camera.open(currentCameraID);
camera.setDisplayOrientation(frontCameraDegrees); //让相机旋转一定度数
camera.setPreviewDisplay(surfaceView.getHolder());
camera.setPreviewCallback(previewCallback);
camera.startPreview();
}
} catch (Exception e) {
e.printStackTrace();
}
break;
default:
break;
}
}
/**
* 摄像头是否存在
*
* @return true：摄像头存在
*/
private boolean checkCamera() {
return this.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
}
/**
* context - 上下文对象
* detectMode - 检测模式，支持视频模式(ASF_DETECT_MODE_VIDEO)和图像模式(ASF_DETECT_MODE_IMAGE)
* detectFaceOrientPriority - 人脸检测方向的优先级，支持仅0度(ASF_OP_0_ONLY)，仅90度(ASF_OP_90_ONLY)，仅180度(ASF_OP_180_ONLY)，仅270度(ASF_OP_270_ONLY)，多方向检测(ASF_OP_0_HIGHER_EXT)
* detectFaceScaleVal - 人脸相对于所在图片的长边的占比，在视频模式(ASF_DETECT_MODE_VIDEO)下有效值范围[2，16]，在图像模式(ASF_DETECT_MODE_IMAGE)下有效值范围[2，32]
* detectFaceMaxNum - 引擎最多能检测出的人脸数，有效值范围[1,50]
* combinedMask - 初始化引擎功能组合，可以是ASF_NONE、ASF_FACE_DETECT、ASF_FACE_RECOGNITION、ASF_AGE、ASF_GENDER、ASF_FACE3DANGLE、ASF_LIVENESS中的单个或者多个，用 | 运算符拼接
*
* @return FaceEngine是否初始化成功
*/
private boolean faceEngineIsInit() {
int faceEngineInit = ZffApplication.getFaceEngine().init(this, DetectMode.ASF_DETECT_MODE_VIDEO, DetectFaceOrientPriority.ASF_OP_ALL_OUT, 16, 1, FaceEngine.ASF_FACE_DETECT | FaceEngine.ASF_FACE_RECOGNITION | FaceEngine.ASF_AGE | FaceEngine.ASF_GENDER | FaceEngine.ASF_FACE3DANGLE | FaceEngine.ASF_LIVENESS | FaceEngine.ASF_IR_LIVENESS);
Log.v("faceEngineInit", faceEngineInit + "");
return faceEngineInit == ErrorInfo.MOK;
}
private synchronized void signInSuccess(Staff staff) {
try {
if ("ALIVE".equals(livenessInfo)) {
QueryBuilder<Attendance> queryBuilder = attendanceDao.queryBuilder();
queryBuilder.where(AttendanceDao.Properties.StaffId.eq(staff.getStaffId()), AttendanceDao.Properties.StaffName.eq(staff.getStaffName()), AttendanceDao.Properties.StaffDepartment.eq(staff.getStaffDepartment()), queryBuilder.or(AttendanceDao.Properties.SignInTime.gt(today), AttendanceDao.Properties.SignOutTime.gt(today)));
List<Attendance> attendances = queryBuilder.list();
if (attendances != null && attendances.size() > 0) {
Attendance attendance = attendances.get(0);
if (attendances.get(0).getSignInTime() > 1000) {
signInSuccessUI(attendance, "你已经签到过了");
} else {
attendance.setSignInTime(System.currentTimeMillis());
attendance.setSignInLatitude(latitude);
attendance.setSignInLongitude(longitude);
attendanceDao.update(attendance);
signInSuccessUI(attendance, "恭喜你，上班签到成功。");
}
} else {
Cursor cursor = null;
long attendanceId = 0;
try {
cursor = ZffApplication.getDaoSession(this).getDatabase().rawQuery("select max(ATTENDANCE_ID) MAX_ATTENDANCE_ID from ATTENDANCE", null);
while (cursor.moveToNext()) {
attendanceId = cursor.getLong(cursor.getColumnIndex("MAX_ATTENDANCE_ID")) + 1;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (cursor != null) {
cursor.close();
}
}
Attendance attendance = new Attendance(attendanceId, staff.getStaffId(), staff.getStaffName(), staff.getStaffDepartment(), System.currentTimeMillis(), latitude, longitude,
0L, 0, 0);
attendanceDao.insert(attendance);
signInSuccessUI(attendance, "恭喜你，上班签到成功。");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private synchronized void signInSuccessUI(final Attendance attendance, final String result) {
// if (!"".equals(age.getText().toString()) && !"".equals(gender.getText().toString()) && !"".equals(liveness.getText().toString())) {
// signInSuccess.setVisibility(View.VISIBLE);
// 工号……姓名……时间……签到类型
signInSuccessT.setText(result);
staffId.setText(attendance.getStaffId() + "");
staffName.setText(attendance.getStaffName());
signInTime.setText(simpleDateFormat.format(attendance.getSignInTime()));
new Thread() {
@Override
public void run() {
super.run();
try {
runOnUiThread(new Runnable() {
@Override
public void run() {
signInSuccessLinear.setVisibility(View.VISIBLE);
}
});
Thread.sleep(2000);
runOnUiThread(new Runnable() {
@Override
public void run() {
signInSuccessLinear.setVisibility(View.GONE);
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
// }
}
@Override
protected void onDestroy() {
super.onDestroy();
try {
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.stopPreview();
camera.release();
camera = null;
}
//调用FaceEngine的unInit方法销毁引擎。在init成功后如不unInit会导致内存泄漏。
ZffApplication.getFaceEngine().unInit();
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void onBackPressed() {
super.onBackPressed();
try {
if (camera != null) {
// camera.lock(); //从Android 4.0 (API 14)开始, Camera.lock() 和 Camera.unlock() 的调用已经被自动管理了。
camera.setPreviewCallback(null);
camera.setPreviewDisplay(null);
camera.stopPreview();
camera.release();
camera = null;
}
//调用FaceEngine的unInit方法销毁引擎。在init成功后如不unInit会导致内存泄漏。
ZffApplication.getFaceEngine().unInit();
finish();
} catch (Exception e) {
e.printStackTrace();
}
}
}
| false |
33054_0 | package net.mltpoject.mine.mltpojectmonster.卫道士;
import net.minecraft.ChatFormatting;
import net.minecraft.network.chat.Style;
import net.minecraft.network.chat.TextComponent;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.monster.Monster;
import net.minecraft.world.entity.monster.Vindicator;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.entity.projectile.AbstractArrow;
import net.minecraftforge.common.ForgeConfigSpec;
import net.minecraftforge.event.entity.living.LivingAttackEvent;
import net.minecraftforge.event.entity.living.LivingDeathEvent;
import net.minecraftforge.event.entity.living.LivingEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import net.mltpoject.mine.mltpojectmonster.NBT工具;
import net.mltpoject.mine.mltpojectmonster.能力基类;
@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.FORGE)
public class 午夜凶铃 extends 能力基类 {
public static ForgeConfigSpec.BooleanValue 午夜凶铃启用;
public static ForgeConfigSpec.DoubleValue 午夜凶铃概率;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒时间;
public static ForgeConfigSpec.BooleanValue 午夜凶铃诅咒时间刷新;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒施加量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒递增量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒递减量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒传递附加量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒致死数量;
public 午夜凶铃(){
super("卫道士", "午夜凶铃");
生成订阅类型 = EntityType.VINDICATOR;
}
@Override
protected void 当获取配置(ForgeConfigSpec.Builder 构建) {
午夜凶铃启用 = 构建
.comment("如果启用，卫道士有一定概率会诅咒命中的玩家")
.define("午夜凶铃启用", true);
午夜凶铃概率 = 构建
.comment("卫道士可以诅咒玩家的概率")
.defineInRange("午夜凶铃概率", 0.3, 0, 1);
午夜凶铃诅咒时间 = 构建
.comment("诅咒会持续多长时间")
.defineInRange("午夜凶铃诅咒时间", 8400, 0, Integer.MAX_VALUE);
午夜凶铃诅咒时间刷新 = 构建
.comment("如果启用，当诅咒层数增加后会刷新持续时间")
.define("午夜凶铃诅咒时间刷新", true);
午夜凶铃诅咒施加量 = 构建
.comment("午夜凶铃能力的卫道士每次攻击给玩家施加的诅咒层数")
.defineInRange("午夜凶铃诅咒施加量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒递增量 = 构建
.comment("当被诅咒的玩家被怪物攻击后诅咒增加的数量")
.defineInRange("午夜凶铃诅咒递增量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒递减量 = 构建
.comment("当被诅咒的玩家击杀怪物后诅咒减少的数量")
.defineInRange("午夜凶铃诅咒递减量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒传递附加量 = 构建
.comment("当玩家通过攻击传递诅咒后诅咒会额外增加的数量")
.defineInRange("午夜凶铃诅咒传递附加量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒致死数量 = 构建
.comment("多少层诅咒会让玩家立即去世")
.defineInRange("午夜凶铃诅咒致死数量", 77, 0, Integer.MAX_VALUE);
}
@SubscribeEvent
public void onEntityAttacked(LivingAttackEvent event) {
Entity 攻击者 = event.getSource().getEntity();
LivingEntity 被攻击者 = event.getEntityLiving();
if (!午夜凶铃启用.get()){
return;
}
if (被攻击者 instanceof Player && 攻击者 instanceof Player){
var 玩家 = (Player) 被攻击者;
var 凶手玩家 = (Player) 攻击者;
if (获取诅咒层数(凶手玩家) > 0){
添加诅咒(获取诅咒层数(凶手玩家) + 午夜凶铃诅咒传递附加量.get(), 玩家);
TextComponent 对凶手说 = new TextComponent("你将");
对凶手说.append(new TextComponent(Integer.toString(获取诅咒层数(玩家))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(玩家)))));
对凶手说.append("层诅咒传递给了");
对凶手说.append(玩家.getName());
TextComponent 对目标说 = new TextComponent("你被");
对目标说.append(玩家.getName());
对目标说.append("传递了");
对目标说.append(new TextComponent(Integer.toString(获取诅咒层数(玩家))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(玩家)))));
对目标说.append("层诅咒(满层" + 午夜凶铃诅咒致死数量.get() +")");
消除诅咒(凶手玩家);
发送能力提示(对目标说, 玩家);
发送能力提示(对凶手说, 凶手玩家);
if (午夜凶铃诅咒时间刷新.get()){
持续时间重置(玩家);
}
}
}
if (被攻击者 instanceof Player && 攻击者 instanceof Monster){
var 玩家 = (Player) 被攻击者;
if (获取诅咒层数(玩家) > 0){
添加诅咒(午夜凶铃诅咒递增量.get(), 玩家);
if (!(攻击者 instanceof Vindicator)){
TextComponent message = new TextComponent("诅咒正在加剧，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数(被攻击者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(被攻击者)))));
发送能力提示(message, 玩家);
if (午夜凶铃诅咒时间刷新.get()){
持续时间重置(被攻击者);
}
}
}
}
if (被攻击者 instanceof Player && 攻击者 instanceof Vindicator) {
Vindicator 卫道士 = (Vindicator) 攻击者;
if (!NBT工具.获取NBTBool("午夜凶铃", 卫道士)){
return;
}
TextComponent message;
if (获取诅咒层数(被攻击者) <= 0){
添加诅咒(午夜凶铃诅咒施加量.get(), 被攻击者);
message = new TextComponent("你被诅咒了，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数(被攻击者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(被攻击者)))));
持续时间重置(被攻击者);
}
else{
添加诅咒(午夜凶铃诅咒施加量.get(), 被攻击者);
message = new TextComponent("诅咒正在加剧，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数(被攻击者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(被攻击者)))));
if (午夜凶铃诅咒时间刷新.get()){
持续时间重置(被攻击者);
}
}
发送能力提示(message, (Player) 被攻击者);
}
}
@SubscribeEvent
public void onLivingUpdate(LivingEvent.LivingUpdateEvent event) {
if (event.getEntityLiving() instanceof Player){
var 玩家 = (Player) event.getEntityLiving();
var 诅咒层数 = 获取诅咒层数(玩家);
if (诅咒层数 >= 午夜凶铃诅咒致死数量.get()){
玩家.die(DamageSource.MAGIC);
return;
}
if (诅咒层数 > 0){
持续时间步进(玩家);
if (是否结束(玩家)){
消除诅咒(玩家);
TextComponent message = new TextComponent("诅咒已经随时间消散了");
发送能力提示(message, 玩家);
}
}
}
}
@SubscribeEvent
public void onEntityDeath(LivingDeathEvent event) {
if (event.getEntityLiving() instanceof Monster){
// 获取击杀者
Entity 击杀者 = event.getSource().getEntity();
if (击杀者 instanceof AbstractArrow){
击杀者 = ((AbstractArrow) 击杀者).getOwner();
}
if (击杀者 == null){
return;
}
if (击杀者 instanceof Player){
var 诅咒数量 = 获取诅咒层数((Player) 击杀者);
if (诅咒数量 > 0){
添加诅咒(0 - 午夜凶铃诅咒递减量.get(), (Player) 击杀者);
TextComponent message = new TextComponent("诅咒正在衰退，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数((Player) 击杀者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数((Player) 击杀者)))));
发送能力提示(message, (Player) 击杀者);
}
}
}
}
@Override
protected void 当订阅生物生成(LivingEntity 生物) {
if (Math.random() < 午夜凶铃概率.get()) {
NBT工具.添加NBT("午夜凶铃", true, 生物);
}
}
private static int 获取诅咒层数(LivingEntity 实体){
return NBT工具.获取NBTInt("午夜凶铃诅咒", 实体);
}
private static void 添加诅咒(int 数量, LivingEntity 实体){
var 当前层数 = 获取诅咒层数(实体);
NBT工具.添加NBT("午夜凶铃诅咒", 当前层数 + 数量, 实体);
}
private static void 消除诅咒(LivingEntity 实体){
NBT工具.添加NBT("午夜凶铃诅咒", 0, 实体);
}
private static boolean 是否结束(LivingEntity 实体){
return 获取持续时间计时(实体) <= 0;
}
private static int 获取持续时间计时(LivingEntity 实体){
return NBT工具.获取NBTInt("午夜凶铃计时器", 实体);
}
private static void 持续时间步进(LivingEntity 实体){
var 当前时间 = 获取持续时间计时(实体);
NBT工具.添加NBT("午夜凶铃计时器", 当前时间 - 1, 实体);
}
private static void 持续时间重置(LivingEntity 实体){
NBT工具.添加NBT("午夜凶铃计时器", 午夜凶铃诅咒时间.get(), 实体);
}
private static ChatFormatting 数字颜色(int 诅咒层数){
var 致死量 = 午夜凶铃诅咒致死数量.get();
if (诅咒层数 < 致死量 * 0.1){
return ChatFormatting.GREEN;
}
if (诅咒层数 < 致死量 * 0.3){
return ChatFormatting.YELLOW;
}
if (诅咒层数 < 致死量 * 0.6){
return ChatFormatting.GOLD;
}
if (诅咒层数 < 致死量 * 0.9){
return ChatFormatting.DARK_PURPLE;
}
return ChatFormatting.DARK_RED;
}
}
| MLT5419/MLTPojectMonster | src/main/java/net/mltpoject/mine/mltpojectmonster/卫道士/午夜凶铃.java | 3,491 | // 获取击杀者 | line_comment | zh-cn | package net.mltpoject.mine.mltpojectmonster.卫道士;
import net.minecraft.ChatFormatting;
import net.minecraft.network.chat.Style;
import net.minecraft.network.chat.TextComponent;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.monster.Monster;
import net.minecraft.world.entity.monster.Vindicator;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.entity.projectile.AbstractArrow;
import net.minecraftforge.common.ForgeConfigSpec;
import net.minecraftforge.event.entity.living.LivingAttackEvent;
import net.minecraftforge.event.entity.living.LivingDeathEvent;
import net.minecraftforge.event.entity.living.LivingEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import net.mltpoject.mine.mltpojectmonster.NBT工具;
import net.mltpoject.mine.mltpojectmonster.能力基类;
@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.FORGE)
public class 午夜凶铃 extends 能力基类 {
public static ForgeConfigSpec.BooleanValue 午夜凶铃启用;
public static ForgeConfigSpec.DoubleValue 午夜凶铃概率;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒时间;
public static ForgeConfigSpec.BooleanValue 午夜凶铃诅咒时间刷新;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒施加量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒递增量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒递减量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒传递附加量;
public static ForgeConfigSpec.IntValue 午夜凶铃诅咒致死数量;
public 午夜凶铃(){
super("卫道士", "午夜凶铃");
生成订阅类型 = EntityType.VINDICATOR;
}
@Override
protected void 当获取配置(ForgeConfigSpec.Builder 构建) {
午夜凶铃启用 = 构建
.comment("如果启用，卫道士有一定概率会诅咒命中的玩家")
.define("午夜凶铃启用", true);
午夜凶铃概率 = 构建
.comment("卫道士可以诅咒玩家的概率")
.defineInRange("午夜凶铃概率", 0.3, 0, 1);
午夜凶铃诅咒时间 = 构建
.comment("诅咒会持续多长时间")
.defineInRange("午夜凶铃诅咒时间", 8400, 0, Integer.MAX_VALUE);
午夜凶铃诅咒时间刷新 = 构建
.comment("如果启用，当诅咒层数增加后会刷新持续时间")
.define("午夜凶铃诅咒时间刷新", true);
午夜凶铃诅咒施加量 = 构建
.comment("午夜凶铃能力的卫道士每次攻击给玩家施加的诅咒层数")
.defineInRange("午夜凶铃诅咒施加量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒递增量 = 构建
.comment("当被诅咒的玩家被怪物攻击后诅咒增加的数量")
.defineInRange("午夜凶铃诅咒递增量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒递减量 = 构建
.comment("当被诅咒的玩家击杀怪物后诅咒减少的数量")
.defineInRange("午夜凶铃诅咒递减量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒传递附加量 = 构建
.comment("当玩家通过攻击传递诅咒后诅咒会额外增加的数量")
.defineInRange("午夜凶铃诅咒传递附加量", 1, 0, Integer.MAX_VALUE);
午夜凶铃诅咒致死数量 = 构建
.comment("多少层诅咒会让玩家立即去世")
.defineInRange("午夜凶铃诅咒致死数量", 77, 0, Integer.MAX_VALUE);
}
@SubscribeEvent
public void onEntityAttacked(LivingAttackEvent event) {
Entity 攻击者 = event.getSource().getEntity();
LivingEntity 被攻击者 = event.getEntityLiving();
if (!午夜凶铃启用.get()){
return;
}
if (被攻击者 instanceof Player && 攻击者 instanceof Player){
var 玩家 = (Player) 被攻击者;
var 凶手玩家 = (Player) 攻击者;
if (获取诅咒层数(凶手玩家) > 0){
添加诅咒(获取诅咒层数(凶手玩家) + 午夜凶铃诅咒传递附加量.get(), 玩家);
TextComponent 对凶手说 = new TextComponent("你将");
对凶手说.append(new TextComponent(Integer.toString(获取诅咒层数(玩家))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(玩家)))));
对凶手说.append("层诅咒传递给了");
对凶手说.append(玩家.getName());
TextComponent 对目标说 = new TextComponent("你被");
对目标说.append(玩家.getName());
对目标说.append("传递了");
对目标说.append(new TextComponent(Integer.toString(获取诅咒层数(玩家))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(玩家)))));
对目标说.append("层诅咒(满层" + 午夜凶铃诅咒致死数量.get() +")");
消除诅咒(凶手玩家);
发送能力提示(对目标说, 玩家);
发送能力提示(对凶手说, 凶手玩家);
if (午夜凶铃诅咒时间刷新.get()){
持续时间重置(玩家);
}
}
}
if (被攻击者 instanceof Player && 攻击者 instanceof Monster){
var 玩家 = (Player) 被攻击者;
if (获取诅咒层数(玩家) > 0){
添加诅咒(午夜凶铃诅咒递增量.get(), 玩家);
if (!(攻击者 instanceof Vindicator)){
TextComponent message = new TextComponent("诅咒正在加剧，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数(被攻击者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(被攻击者)))));
发送能力提示(message, 玩家);
if (午夜凶铃诅咒时间刷新.get()){
持续时间重置(被攻击者);
}
}
}
}
if (被攻击者 instanceof Player && 攻击者 instanceof Vindicator) {
Vindicator 卫道士 = (Vindicator) 攻击者;
if (!NBT工具.获取NBTBool("午夜凶铃", 卫道士)){
return;
}
TextComponent message;
if (获取诅咒层数(被攻击者) <= 0){
添加诅咒(午夜凶铃诅咒施加量.get(), 被攻击者);
message = new TextComponent("你被诅咒了，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数(被攻击者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(被攻击者)))));
持续时间重置(被攻击者);
}
else{
添加诅咒(午夜凶铃诅咒施加量.get(), 被攻击者);
message = new TextComponent("诅咒正在加剧，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数(被攻击者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数(被攻击者)))));
if (午夜凶铃诅咒时间刷新.get()){
持续时间重置(被攻击者);
}
}
发送能力提示(message, (Player) 被攻击者);
}
}
@SubscribeEvent
public void onLivingUpdate(LivingEvent.LivingUpdateEvent event) {
if (event.getEntityLiving() instanceof Player){
var 玩家 = (Player) event.getEntityLiving();
var 诅咒层数 = 获取诅咒层数(玩家);
if (诅咒层数 >= 午夜凶铃诅咒致死数量.get()){
玩家.die(DamageSource.MAGIC);
return;
}
if (诅咒层数 > 0){
持续时间步进(玩家);
if (是否结束(玩家)){
消除诅咒(玩家);
TextComponent message = new TextComponent("诅咒已经随时间消散了");
发送能力提示(message, 玩家);
}
}
}
}
@SubscribeEvent
public void onEntityDeath(LivingDeathEvent event) {
if (event.getEntityLiving() instanceof Monster){
// 获取 <SUF>
Entity 击杀者 = event.getSource().getEntity();
if (击杀者 instanceof AbstractArrow){
击杀者 = ((AbstractArrow) 击杀者).getOwner();
}
if (击杀者 == null){
return;
}
if (击杀者 instanceof Player){
var 诅咒数量 = 获取诅咒层数((Player) 击杀者);
if (诅咒数量 > 0){
添加诅咒(0 - 午夜凶铃诅咒递减量.get(), (Player) 击杀者);
TextComponent message = new TextComponent("诅咒正在衰退，当前诅咒层数(满层" + 午夜凶铃诅咒致死数量.get() +")：");
message.append(new TextComponent(Integer.toString(获取诅咒层数((Player) 击杀者))).setStyle(Style.EMPTY.withColor(数字颜色(获取诅咒层数((Player) 击杀者)))));
发送能力提示(message, (Player) 击杀者);
}
}
}
}
@Override
protected void 当订阅生物生成(LivingEntity 生物) {
if (Math.random() < 午夜凶铃概率.get()) {
NBT工具.添加NBT("午夜凶铃", true, 生物);
}
}
private static int 获取诅咒层数(LivingEntity 实体){
return NBT工具.获取NBTInt("午夜凶铃诅咒", 实体);
}
private static void 添加诅咒(int 数量, LivingEntity 实体){
var 当前层数 = 获取诅咒层数(实体);
NBT工具.添加NBT("午夜凶铃诅咒", 当前层数 + 数量, 实体);
}
private static void 消除诅咒(LivingEntity 实体){
NBT工具.添加NBT("午夜凶铃诅咒", 0, 实体);
}
private static boolean 是否结束(LivingEntity 实体){
return 获取持续时间计时(实体) <= 0;
}
private static int 获取持续时间计时(LivingEntity 实体){
return NBT工具.获取NBTInt("午夜凶铃计时器", 实体);
}
private static void 持续时间步进(LivingEntity 实体){
var 当前时间 = 获取持续时间计时(实体);
NBT工具.添加NBT("午夜凶铃计时器", 当前时间 - 1, 实体);
}
private static void 持续时间重置(LivingEntity 实体){
NBT工具.添加NBT("午夜凶铃计时器", 午夜凶铃诅咒时间.get(), 实体);
}
private static ChatFormatting 数字颜色(int 诅咒层数){
var 致死量 = 午夜凶铃诅咒致死数量.get();
if (诅咒层数 < 致死量 * 0.1){
return ChatFormatting.GREEN;
}
if (诅咒层数 < 致死量 * 0.3){
return ChatFormatting.YELLOW;
}
if (诅咒层数 < 致死量 * 0.6){
return ChatFormatting.GOLD;
}
if (诅咒层数 < 致死量 * 0.9){
return ChatFormatting.DARK_PURPLE;
}
return ChatFormatting.DARK_RED;
}
}
| false |
63448_1 | package com.itheima.contrast;
public class Demo1Oop {
/*
需求: 遍历打印数组, 要求结果为[11, 22, 33, 44, 55]
面向对象思想: 指挥 [对象] 来实现需求
*/
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
// 1. 创建数组服务员对象
数组服务员 二狗 = new 数组服务员();
// 2. 指挥二狗对象, 调用内部的printArray方法遍历打印数组
二狗.遍历打印数组(arr);
}
}
| MN-ctx/JAVASE | day221128/mOop/src/com/itheima/contrast/Demo1Oop.java | 173 | // 1. 创建数组服务员对象
| line_comment | zh-cn | package com.itheima.contrast;
public class Demo1Oop {
/*
需求: 遍历打印数组, 要求结果为[11, 22, 33, 44, 55]
面向对象思想: 指挥 [对象] 来实现需求
*/
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
// 1. <SUF>
数组服务员 二狗 = new 数组服务员();
// 2. 指挥二狗对象, 调用内部的printArray方法遍历打印数组
二狗.遍历打印数组(arr);
}
}
| false |
10492_0 | package com.mobin.thread;
/**
* Created by Mobin on 2016/1/27.
* 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。
*/
public class MainAndSubCyclical {
public static void main(String[] args) {
final Common common = new Common();
new Thread(
new Runnable() {
public void run() {
for (int i = 1; i <= 50; i++) {
common.sub(i);
}
}
}
).start();
for (int i = 1; i <= 50; i++) {
common.main(i);
}
}
}
class Common{
private boolean sub = true;
public synchronized void sub(int i){
while (!sub) { //用while而不用if可以避免虚假唤醒
try {
this.wait(); //等待，主main运行完
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++) {
System.out.println("sub " + j + " loop of " + i);
}
sub = false;
this.notify();
}
public synchronized void main(int i){
while(sub) {
try {
this.wait(); //等待让sub运行完
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++) {
System.out.println("main " + j + " loop of " + i);
}
sub = true;
this.notify();
}
}
| MOBIN-F/Thread | src/com/mobin/thread/MainAndSubCyclical.java | 431 | /**
* Created by Mobin on 2016/1/27.
* 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。
*/ | block_comment | zh-cn | package com.mobin.thread;
/**
* Cre <SUF>*/
public class MainAndSubCyclical {
public static void main(String[] args) {
final Common common = new Common();
new Thread(
new Runnable() {
public void run() {
for (int i = 1; i <= 50; i++) {
common.sub(i);
}
}
}
).start();
for (int i = 1; i <= 50; i++) {
common.main(i);
}
}
}
class Common{
private boolean sub = true;
public synchronized void sub(int i){
while (!sub) { //用while而不用if可以避免虚假唤醒
try {
this.wait(); //等待，主main运行完
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++) {
System.out.println("sub " + j + " loop of " + i);
}
sub = false;
this.notify();
}
public synchronized void main(int i){
while(sub) {
try {
this.wait(); //等待让sub运行完
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++) {
System.out.println("main " + j + " loop of " + i);
}
sub = true;
this.notify();
}
}
| false |
18153_22 | package com.mobin.convert;
import com.github.stuxuhai.jpinyin.PinyinFormat;
import com.github.stuxuhai.jpinyin.PinyinHelper;
import com.mobin.util.TST;
import org.apache.commons.collections.map.HashedMap;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* Created by hadoop on 3/9/16.
*/
public class ConvertMapper extends Mapper<LongWritable, Text, NullWritable, Text> {
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
private SimpleDateFormat f = new SimpleDateFormat("yy年MM月dd日");
private InputStream inputStream;
private Properties properties;
private TST<String> tst;
private Text valueText;
protected void setup(Mapper<LongWritable, Text, NullWritable, Text>.Context context)
throws IOException, InterruptedException {
tst=new TST<String>();
valueText=new Text();
inputStream=getClass().getResourceAsStream("/interest.properties");
properties=new Properties();
properties.load(inputStream);
Set<String> stringPropertyNames = properties.stringPropertyNames();
for (String intresting : stringPropertyNames) {
tst.put(intresting, properties.getProperty(intresting));
}
}
protected void map(LongWritable key, Text value,
Context context)
throws IOException, InterruptedException {
String[] _info = null;
String[] info = value.toString().split("\t");
double _touristSpots = touristSpots(info[4].replaceAll("[\\[\\]]", "").split(","));
double _shop = shopping(info[15]);
try {
_info = change(info[5]);
} catch (ParseException e) {
e.printStackTrace();
}
double _hotel = hotel(info[14]);
// info[5] = hoteled(info[5]);
String hotellevel = hoteled(info[14]);
String trafficlevel = trafficLevel(info[8]);
double _traffic = traffic(info[8]);
double _sight = info[4].substring(1, info[4].length() - 1).split(",").length * 0.3;
double total = (_hotel + _traffic + _sight + _touristSpots + _shop) / Integer.valueOf(info[7]);
String _total = String.format("%.19f", total);
StringBuffer sb = new StringBuffer();
String values = sb //将Jpingyin的jar包放到各节点的Hadoop包目录下，否则会出现couldnotfoundclass错误
.append(info[0]).append("\t")
//出发点(拼音)
.append(PinyinHelper.convertToPinyinString(info[1].replaceAll("[\\[\\]]", ""),"", PinyinFormat.WITHOUT_TONE)).append("\t")
//目的地(拼音)
.append(PinyinHelper.convertToPinyinString(info[2].replaceAll("[\\[\\]]", ""),"", PinyinFormat.WITHOUT_TONE)).append("\t")
//标题
.append(info[3].replaceAll("[\\[\\]]", "")).append("\t")
//目的地
.append(info[4].replaceAll("[\\[\\]]", "")).append("\t")
//出发时间
.append(String.valueOf(_info[0])).append("\t")
//结束时间
//.append(String.valueOf(_info[1])).append("\t")
//出游天数
.append(info[6]).append("\t")
//价格
.append(info[7]).append("\t")
//交通方式
.append(info[8]).append("\t")
//是否往返
.append(info[9]).append("\t")
//是否直达
.append(info[10]).append("\t")
//跟团游
.append(info[11]).append("\t")
//图片
.append(info[12]).append("\t")
//代理
.append(info[13]).append("\t")
//酒店
.append(info[14]).append("\t")
//数据来源
.append("去哪儿网").append("\t")
//酒店等级
.append(hotellevel).append("\t")
//出发点
.append((info[1].replaceAll("[\\[\\]]", ""))).append("\t")
//目的地
.append((info[2].replaceAll("[\\[\\]]", ""))).append("\t")
//性价比
.append(_total).append("\t")
//交通工具
.append(trafficlevel).append("\t")
.toString();
context.write(NullWritable.get(), new Text(values));
}
public String[] change(String info) throws ParseException {
String ST = "";
String ET = "";
String[] s = new String[2];
if (info.contains("天天")) {
ST = sdf.format(new Date());
ET = sdf.format(f.parse("17年01月01日"));
} else if (info.contains("多团期")) {
String[] _info = info.substring(0, info.lastIndexOf("多团期")).split("\\...");
ST = ST(_info[0]);
ET = ET(_info[1]);
} else if (info.contains("-")) {
String[] _info = info.split("-");
ST = ST(_info[0]);
ET = ET(_info[1]);
}
s[0] = ST;
s[1] = ET;
return s;
}
public String ST(String st) throws ParseException {
return sdf.format(f.parse("16年" + st));
}
public String ET(String et) throws ParseException {
return sdf.format(f.parse("16年" + et));
}
////估算酒店星性价比
public double hotel(String hotel) {
double _hotel = 0.21;
if (hotel.contains("经济型")) {
_hotel = _hotel * 2;
} else if (hotel.contains("舒适型")) {
_hotel = _hotel * 3;
} else if (hotel.contains("高档型")) {
_hotel = _hotel * 4;
} else if (hotel.contains("豪华型")) {
_hotel = _hotel * 5;
}else{
_hotel = _hotel * 1;
}
return _hotel;
}
//计算旅游天数的性价比
public double tData(String data){
double _data = 0.12;
String d = data.split("[\u4e00-\u9fa5]+")[0];
return _data * (Integer.valueOf(d));
}
//判断酒店星级数
public String hoteled(String hotel) {
String level = null;
if (hotel.contains("经济型")) {
level = "2";
} else if (hotel.contains("舒适型")) {
level = "3";
} else if (hotel.contains("高档型")) {
level = "4";
} else if (hotel.contains("豪华型")) {
level = "5";
} else
level = "1";
return level;
}
public String trafficLevel(String traffic) {
if (traffic.contains("航班") || traffic.contains("飞机"))
return "5";
else if (traffic.contains("高铁"))
return "4";
else if (traffic.contains("火车"))
return "3";
else if (traffic.contains("大巴"))
return "2";
else
return "1";
}
public double traffic(String traffic) {
double _traffic = 0.21;
if (traffic.contains("航班") || traffic.contains("飞机")) {
_traffic = _traffic * 5;
} else if (traffic.contains("高铁")) {
_traffic = _traffic * 4;
} else if (traffic.contains("火车")) {
_traffic = _traffic * 3;
} else if (traffic.contains("大巴")) {
_traffic = _traffic * 2;
}
return _traffic;
}
//著名景点个数
public double touristSpots(String[] traffic) {
double _traffic = 0.38;
int count = 0;
for(String s : traffic) {
String p = PinyinHelper.convertToPinyinString(s,"",PinyinFormat.WITHOUT_TONE);
if(!"".equals(p) && p != null){
String i = tst.get(p);
if(i != null)
count ++;
}
}
return count * _traffic;
}
public double shopping(String shop){
double _shop = 0.07;
if(shop.contains("购物"))
return _shop;
else
return 0;
}
}
| MOBIN-F/TravelPriceComparison | src/main/java/com/mobin/convert/ConvertMapper.java | 2,169 | //判断酒店星级数 | line_comment | zh-cn | package com.mobin.convert;
import com.github.stuxuhai.jpinyin.PinyinFormat;
import com.github.stuxuhai.jpinyin.PinyinHelper;
import com.mobin.util.TST;
import org.apache.commons.collections.map.HashedMap;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* Created by hadoop on 3/9/16.
*/
public class ConvertMapper extends Mapper<LongWritable, Text, NullWritable, Text> {
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
private SimpleDateFormat f = new SimpleDateFormat("yy年MM月dd日");
private InputStream inputStream;
private Properties properties;
private TST<String> tst;
private Text valueText;
protected void setup(Mapper<LongWritable, Text, NullWritable, Text>.Context context)
throws IOException, InterruptedException {
tst=new TST<String>();
valueText=new Text();
inputStream=getClass().getResourceAsStream("/interest.properties");
properties=new Properties();
properties.load(inputStream);
Set<String> stringPropertyNames = properties.stringPropertyNames();
for (String intresting : stringPropertyNames) {
tst.put(intresting, properties.getProperty(intresting));
}
}
protected void map(LongWritable key, Text value,
Context context)
throws IOException, InterruptedException {
String[] _info = null;
String[] info = value.toString().split("\t");
double _touristSpots = touristSpots(info[4].replaceAll("[\\[\\]]", "").split(","));
double _shop = shopping(info[15]);
try {
_info = change(info[5]);
} catch (ParseException e) {
e.printStackTrace();
}
double _hotel = hotel(info[14]);
// info[5] = hoteled(info[5]);
String hotellevel = hoteled(info[14]);
String trafficlevel = trafficLevel(info[8]);
double _traffic = traffic(info[8]);
double _sight = info[4].substring(1, info[4].length() - 1).split(",").length * 0.3;
double total = (_hotel + _traffic + _sight + _touristSpots + _shop) / Integer.valueOf(info[7]);
String _total = String.format("%.19f", total);
StringBuffer sb = new StringBuffer();
String values = sb //将Jpingyin的jar包放到各节点的Hadoop包目录下，否则会出现couldnotfoundclass错误
.append(info[0]).append("\t")
//出发点(拼音)
.append(PinyinHelper.convertToPinyinString(info[1].replaceAll("[\\[\\]]", ""),"", PinyinFormat.WITHOUT_TONE)).append("\t")
//目的地(拼音)
.append(PinyinHelper.convertToPinyinString(info[2].replaceAll("[\\[\\]]", ""),"", PinyinFormat.WITHOUT_TONE)).append("\t")
//标题
.append(info[3].replaceAll("[\\[\\]]", "")).append("\t")
//目的地
.append(info[4].replaceAll("[\\[\\]]", "")).append("\t")
//出发时间
.append(String.valueOf(_info[0])).append("\t")
//结束时间
//.append(String.valueOf(_info[1])).append("\t")
//出游天数
.append(info[6]).append("\t")
//价格
.append(info[7]).append("\t")
//交通方式
.append(info[8]).append("\t")
//是否往返
.append(info[9]).append("\t")
//是否直达
.append(info[10]).append("\t")
//跟团游
.append(info[11]).append("\t")
//图片
.append(info[12]).append("\t")
//代理
.append(info[13]).append("\t")
//酒店
.append(info[14]).append("\t")
//数据来源
.append("去哪儿网").append("\t")
//酒店等级
.append(hotellevel).append("\t")
//出发点
.append((info[1].replaceAll("[\\[\\]]", ""))).append("\t")
//目的地
.append((info[2].replaceAll("[\\[\\]]", ""))).append("\t")
//性价比
.append(_total).append("\t")
//交通工具
.append(trafficlevel).append("\t")
.toString();
context.write(NullWritable.get(), new Text(values));
}
public String[] change(String info) throws ParseException {
String ST = "";
String ET = "";
String[] s = new String[2];
if (info.contains("天天")) {
ST = sdf.format(new Date());
ET = sdf.format(f.parse("17年01月01日"));
} else if (info.contains("多团期")) {
String[] _info = info.substring(0, info.lastIndexOf("多团期")).split("\\...");
ST = ST(_info[0]);
ET = ET(_info[1]);
} else if (info.contains("-")) {
String[] _info = info.split("-");
ST = ST(_info[0]);
ET = ET(_info[1]);
}
s[0] = ST;
s[1] = ET;
return s;
}
public String ST(String st) throws ParseException {
return sdf.format(f.parse("16年" + st));
}
public String ET(String et) throws ParseException {
return sdf.format(f.parse("16年" + et));
}
////估算酒店星性价比
public double hotel(String hotel) {
double _hotel = 0.21;
if (hotel.contains("经济型")) {
_hotel = _hotel * 2;
} else if (hotel.contains("舒适型")) {
_hotel = _hotel * 3;
} else if (hotel.contains("高档型")) {
_hotel = _hotel * 4;
} else if (hotel.contains("豪华型")) {
_hotel = _hotel * 5;
}else{
_hotel = _hotel * 1;
}
return _hotel;
}
//计算旅游天数的性价比
public double tData(String data){
double _data = 0.12;
String d = data.split("[\u4e00-\u9fa5]+")[0];
return _data * (Integer.valueOf(d));
}
//判断 <SUF>
public String hoteled(String hotel) {
String level = null;
if (hotel.contains("经济型")) {
level = "2";
} else if (hotel.contains("舒适型")) {
level = "3";
} else if (hotel.contains("高档型")) {
level = "4";
} else if (hotel.contains("豪华型")) {
level = "5";
} else
level = "1";
return level;
}
public String trafficLevel(String traffic) {
if (traffic.contains("航班") || traffic.contains("飞机"))
return "5";
else if (traffic.contains("高铁"))
return "4";
else if (traffic.contains("火车"))
return "3";
else if (traffic.contains("大巴"))
return "2";
else
return "1";
}
public double traffic(String traffic) {
double _traffic = 0.21;
if (traffic.contains("航班") || traffic.contains("飞机")) {
_traffic = _traffic * 5;
} else if (traffic.contains("高铁")) {
_traffic = _traffic * 4;
} else if (traffic.contains("火车")) {
_traffic = _traffic * 3;
} else if (traffic.contains("大巴")) {
_traffic = _traffic * 2;
}
return _traffic;
}
//著名景点个数
public double touristSpots(String[] traffic) {
double _traffic = 0.38;
int count = 0;
for(String s : traffic) {
String p = PinyinHelper.convertToPinyinString(s,"",PinyinFormat.WITHOUT_TONE);
if(!"".equals(p) && p != null){
String i = tst.get(p);
if(i != null)
count ++;
}
}
return count * _traffic;
}
public double shopping(String shop){
double _shop = 0.07;
if(shop.contains("购物"))
return _shop;
else
return 0;
}
}
| false |
37770_0 | package activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import bean.ChatBox_left;
import bean.ChatBox_right;
import com.example.myapplication.R;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class ClubChatActivity extends AppCompatActivity {
public Map<String,String> Arr=new HashMap<>();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_chat);
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
LinearLayout Frame = findViewById(R.id.chat_ChatBox);
Button button=findViewById(R.id.Button_returnClubPage);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
finish();
}
});
Intent intent=this.getIntent();
String name=intent.getStringExtra("ClubData");
TextView textView=findViewById(R.id.chat_ClubName);
textView.setText(name);
Arr.put("金逸 21:01:08","我来全写了");
Arr.put("金逸 21:01:57","OK我写完了");
Arr.put("展驰 21:02:23","写写你的");
Arr.put("陈柯羲 21:03:08","恁强啊");
Arr.put("龚况驰宇 21:04:16","太强");
Arr.put("金逸 21:05:27","我保研了，而且帮你们一起保了");
Arr.put("展驰 21:08:08","okok");
Arr.put("陈柯羲 21:08:08","okok");
Arr.put("龚况驰宇 21:08:08","okok");
Arr.put("哈陛下 21:08:08","okok");
Arr.put("欧西给 21:08:08","okok");
Arr.put("虎哥 21:08:08","okok");
Iterator<String> iterator=Arr.keySet().iterator();
LayoutInflater layoutInflater = LayoutInflater.from(this);
while(iterator.hasNext())
{
String key=iterator.next();
if(key.contains("陈柯羲"))
{
ChatBox_right chatBox_right=(ChatBox_right) layoutInflater.inflate(R.layout.chat_box_right_real, null, false);
chatBox_right.setUser_Name(key);
chatBox_right.setUser_Chat(Arr.get(key));
Frame.addView(chatBox_right);
}
else
{
ChatBox_left chatBox_left=(ChatBox_left) layoutInflater.inflate(R.layout.chat_box_left_real, null, false);
chatBox_left.setUser_Name(key);
chatBox_left.setUser_Chat(Arr.get(key));
Frame.addView(chatBox_left);
}
}
}
//绑定发送按钮,用于发送消息
public void sendMessage(){
Button sendButton=findViewById(R.id.sendMessage);
sendButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
EditText inputMessage=findViewById(R.id.chatMessage);
String message=inputMessage.getText().toString();
}
});
}
}
| MQN-80/VideoProject-front | run-tj/app/src/main/java/activity/ClubChatActivity.java | 908 | //绑定发送按钮,用于发送消息 | line_comment | zh-cn | package activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import bean.ChatBox_left;
import bean.ChatBox_right;
import com.example.myapplication.R;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class ClubChatActivity extends AppCompatActivity {
public Map<String,String> Arr=new HashMap<>();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_chat);
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
LinearLayout Frame = findViewById(R.id.chat_ChatBox);
Button button=findViewById(R.id.Button_returnClubPage);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
finish();
}
});
Intent intent=this.getIntent();
String name=intent.getStringExtra("ClubData");
TextView textView=findViewById(R.id.chat_ClubName);
textView.setText(name);
Arr.put("金逸 21:01:08","我来全写了");
Arr.put("金逸 21:01:57","OK我写完了");
Arr.put("展驰 21:02:23","写写你的");
Arr.put("陈柯羲 21:03:08","恁强啊");
Arr.put("龚况驰宇 21:04:16","太强");
Arr.put("金逸 21:05:27","我保研了，而且帮你们一起保了");
Arr.put("展驰 21:08:08","okok");
Arr.put("陈柯羲 21:08:08","okok");
Arr.put("龚况驰宇 21:08:08","okok");
Arr.put("哈陛下 21:08:08","okok");
Arr.put("欧西给 21:08:08","okok");
Arr.put("虎哥 21:08:08","okok");
Iterator<String> iterator=Arr.keySet().iterator();
LayoutInflater layoutInflater = LayoutInflater.from(this);
while(iterator.hasNext())
{
String key=iterator.next();
if(key.contains("陈柯羲"))
{
ChatBox_right chatBox_right=(ChatBox_right) layoutInflater.inflate(R.layout.chat_box_right_real, null, false);
chatBox_right.setUser_Name(key);
chatBox_right.setUser_Chat(Arr.get(key));
Frame.addView(chatBox_right);
}
else
{
ChatBox_left chatBox_left=(ChatBox_left) layoutInflater.inflate(R.layout.chat_box_left_real, null, false);
chatBox_left.setUser_Name(key);
chatBox_left.setUser_Chat(Arr.get(key));
Frame.addView(chatBox_left);
}
}
}
//绑定 <SUF>
public void sendMessage(){
Button sendButton=findViewById(R.id.sendMessage);
sendButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
EditText inputMessage=findViewById(R.id.chatMessage);
String message=inputMessage.getText().toString();
}
});
}
}
| true |
55273_2 | package intern;
import java.util.Arrays;
import java.util.PriorityQueue;
public class MeetingRoom {
public static int minMeetingRooms(int[][] intervals) {
// 先考虑特殊情况
if (intervals == null || intervals.length == 0)
return 0;
// 从定义排序按照进入时间排序
Arrays.sort(intervals, (v1, v2) -> (v1[0] - v2[0]));
// 定义一个优先队列
PriorityQueue<Integer> heap = new PriorityQueue<>();
// 一个计数器
int meetingCount = 0;
for (int[] meeting : intervals){
//要是堆非空，当前会议的开始时间已经大于等于了最小的结束时间
// 这里就是要把所有已经结束的会议淘汰出去
while (!heap.isEmpty() && meeting[0] >= heap.peek()){
heap.poll();
}
// 再把当前会议的结束时间加进去
heap.add(meeting[1]); // 堆里有的就是进行的会议的数量
// 谈话不断的看是不是最大的
meetingCount = Math.max(meetingCount, heap.size());
}
return meetingCount;
}
public static void main(String[] args) {
int[][] interval = {{0,30},{5,10},{15,20}};
System.out.println(minMeetingRooms(interval));
PriorityQueue<Integer> heap = new PriorityQueue<>();
heap.add(1);
heap.add(2);
//System.out.println(heap.peek());
}
}
| MR-Wang13/LC | src/intern/MeetingRoom.java | 375 | // 定义一个优先队列 | line_comment | zh-cn | package intern;
import java.util.Arrays;
import java.util.PriorityQueue;
public class MeetingRoom {
public static int minMeetingRooms(int[][] intervals) {
// 先考虑特殊情况
if (intervals == null || intervals.length == 0)
return 0;
// 从定义排序按照进入时间排序
Arrays.sort(intervals, (v1, v2) -> (v1[0] - v2[0]));
// 定义 <SUF>
PriorityQueue<Integer> heap = new PriorityQueue<>();
// 一个计数器
int meetingCount = 0;
for (int[] meeting : intervals){
//要是堆非空，当前会议的开始时间已经大于等于了最小的结束时间
// 这里就是要把所有已经结束的会议淘汰出去
while (!heap.isEmpty() && meeting[0] >= heap.peek()){
heap.poll();
}
// 再把当前会议的结束时间加进去
heap.add(meeting[1]); // 堆里有的就是进行的会议的数量
// 谈话不断的看是不是最大的
meetingCount = Math.max(meetingCount, heap.size());
}
return meetingCount;
}
public static void main(String[] args) {
int[][] interval = {{0,30},{5,10},{15,20}};
System.out.println(minMeetingRooms(interval));
PriorityQueue<Integer> heap = new PriorityQueue<>();
heap.add(1);
heap.add(2);
//System.out.println(heap.peek());
}
}
| true |
46271_2 | package com.leigq.www.util;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base32;
import org.apache.tomcat.util.codec.binary.Base64;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
/**
* GoogleAuthenticator
* 参考：
* <a href='https://blog.csdn.net/lizhengjava/article/details/76947962'>Google Authenticator 原理及Java实现<a/>
* <br/>
* <a href='https://blog.csdn.net/youanyyou/article/details/81937753'>两步验证杀手锏：Java 接入 Google 身份验证器实战<a/>
* <p>
* 自从google出了双重身份验证后，就方便了大家，等同于有了google一个级别的安全，但是我们该怎么使用google authenticator (双重身份验证)，
* 下面是java的算法，这样大家都可以得到根据key得到公共的秘钥了,直接复制，记得导入JAR包：
* commons-codec-1.8.jar
* junit-4.10.jar
* 创建人：LeiGQ <br>
* 创建时间：2019-03-15 16:15 <br>
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
*/
@Slf4j
public class GoogleAuthenticator {
// taken from Google pam docs - we probably don't need to mess with these
private static final int SECRET_SIZE = 10;
// 种子， 有点像加盐
private static final String SEED = "g8GjEvTbW5oVSV7avLBdwIHqGlUYNzKFI7izOF8GwLDVKs2m0QN7vxRs2im5MDaNCWGmcD2rvcZx";
// 随机数字算法
private static final String RANDOM_NUMBER_ALGORITHM = "SHA1PRNG";
private int window_size = 3; // default 3 - max 17 (from google docs)最多可偏移的时间
private void setWindowSize(int s) {
if (s >= 1 && s <= 17)
window_size = s;
}
/**
* 生成密钥
* <br>创建人： leiGQ
* <br>创建时间： 2019-03-15 16:27
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
* <br>
*/
public static String generateSecretKey() {
try {
SecureRandom sr = SecureRandom.getInstance(RANDOM_NUMBER_ALGORITHM);
sr.setSeed(Base64.decodeBase64(SEED));
byte[] buffer = sr.generateSeed(SECRET_SIZE);
Base32 codec = new Base32();
byte[] bEncodedKey = codec.encode(buffer);
return new String(bEncodedKey);
}catch (NoSuchAlgorithmException e) {
log.error("生成密钥异常：", e);
}
return null;
}
/**
* 获取QR条形码URL, 用这个生成二维码，给Google验证器扫
* <br>创建人： leiGQ
* <br>创建时间： 2019-03-15 16:29
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
* <br>
*/
public static String getQRBarcodeURL(String user, String host, String secret) {
String format = "https://www.google.com/chart?chs=200x200&chld=M%%7C0&cht=qr&chl=otpauth://totp/%s@%s%%3Fsecret%%3D%s";
return String.format(format, user, host, secret);
}
/**
* 验证码动态验证码
* <br>创建人： leiGQ
* <br>创建时间： 2019-03-15 16:31
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
* <br>
* @param secret 密码，上面方法生成的
* @param code 动态验证码
* @param timeMsec 毫秒时间搓 System.currentTimeMillis()
*/
public boolean checkCode(String secret, long code, long timeMsec) {
Base32 codec = new Base32();
byte[] decodedKey = codec.decode(secret);
// convert unix msec time into a 30 second "window"
// this is per the TOTP spec (see the RFC for details)
long t = (timeMsec / 1000L) / 30L;
// Window is used to check codes generated in the near past.
// You can use this value to tune how far you're willing to go.
for (int i = -window_size; i <= window_size; ++i) {
long hash;
try {
hash = verifyCode(decodedKey, t + i);
}catch (Exception e) {
// Yes, this is bad form - but
// the exceptions thrown would be rare and a static configuration problem
e.printStackTrace();
throw new RuntimeException(e.getMessage());
//return false;
}
if (hash == code) {
return true;
}
}
// The validation code is invalid.
return false;
}
private static int verifyCode(byte[] key, long t) throws NoSuchAlgorithmException, InvalidKeyException {
byte[] data = new byte[8];
long value = t;
for (int i = 8; i-- > 0; value >>>= 8) {
data[i] = (byte) value;
}
SecretKeySpec signKey = new SecretKeySpec(key, "HmacSHA1");
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(signKey);
byte[] hash = mac.doFinal(data);
int offset = hash[20 - 1] & 0xF;
// We're using a long because Java hasn't got unsigned int.
long truncatedHash = 0;
for (int i = 0; i < 4; ++i) {
truncatedHash <<= 8;
// We are dealing with signed bytes:
// we just keep the first byte.
truncatedHash |= (hash[offset + i] & 0xFF);
}
truncatedHash &= 0x7FFFFFFF;
truncatedHash %= 1000000;
return (int) truncatedHash;
}
}
| MRLEILOVE/google-authenticator | src/main/java/com/leigq/www/util/GoogleAuthenticator.java | 1,641 | // 种子， 有点像加盐 | line_comment | zh-cn | package com.leigq.www.util;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base32;
import org.apache.tomcat.util.codec.binary.Base64;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
/**
* GoogleAuthenticator
* 参考：
* <a href='https://blog.csdn.net/lizhengjava/article/details/76947962'>Google Authenticator 原理及Java实现<a/>
* <br/>
* <a href='https://blog.csdn.net/youanyyou/article/details/81937753'>两步验证杀手锏：Java 接入 Google 身份验证器实战<a/>
* <p>
* 自从google出了双重身份验证后，就方便了大家，等同于有了google一个级别的安全，但是我们该怎么使用google authenticator (双重身份验证)，
* 下面是java的算法，这样大家都可以得到根据key得到公共的秘钥了,直接复制，记得导入JAR包：
* commons-codec-1.8.jar
* junit-4.10.jar
* 创建人：LeiGQ <br>
* 创建时间：2019-03-15 16:15 <br>
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
*/
@Slf4j
public class GoogleAuthenticator {
// taken from Google pam docs - we probably don't need to mess with these
private static final int SECRET_SIZE = 10;
// 种子 <SUF>
private static final String SEED = "g8GjEvTbW5oVSV7avLBdwIHqGlUYNzKFI7izOF8GwLDVKs2m0QN7vxRs2im5MDaNCWGmcD2rvcZx";
// 随机数字算法
private static final String RANDOM_NUMBER_ALGORITHM = "SHA1PRNG";
private int window_size = 3; // default 3 - max 17 (from google docs)最多可偏移的时间
private void setWindowSize(int s) {
if (s >= 1 && s <= 17)
window_size = s;
}
/**
* 生成密钥
* <br>创建人： leiGQ
* <br>创建时间： 2019-03-15 16:27
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
* <br>
*/
public static String generateSecretKey() {
try {
SecureRandom sr = SecureRandom.getInstance(RANDOM_NUMBER_ALGORITHM);
sr.setSeed(Base64.decodeBase64(SEED));
byte[] buffer = sr.generateSeed(SECRET_SIZE);
Base32 codec = new Base32();
byte[] bEncodedKey = codec.encode(buffer);
return new String(bEncodedKey);
}catch (NoSuchAlgorithmException e) {
log.error("生成密钥异常：", e);
}
return null;
}
/**
* 获取QR条形码URL, 用这个生成二维码，给Google验证器扫
* <br>创建人： leiGQ
* <br>创建时间： 2019-03-15 16:29
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
* <br>
*/
public static String getQRBarcodeURL(String user, String host, String secret) {
String format = "https://www.google.com/chart?chs=200x200&chld=M%%7C0&cht=qr&chl=otpauth://totp/%s@%s%%3Fsecret%%3D%s";
return String.format(format, user, host, secret);
}
/**
* 验证码动态验证码
* <br>创建人： leiGQ
* <br>创建时间： 2019-03-15 16:31
* <p>
* 修改人： <br>
* 修改时间： <br>
* 修改备注： <br>
* </p>
* <br>
* @param secret 密码，上面方法生成的
* @param code 动态验证码
* @param timeMsec 毫秒时间搓 System.currentTimeMillis()
*/
public boolean checkCode(String secret, long code, long timeMsec) {
Base32 codec = new Base32();
byte[] decodedKey = codec.decode(secret);
// convert unix msec time into a 30 second "window"
// this is per the TOTP spec (see the RFC for details)
long t = (timeMsec / 1000L) / 30L;
// Window is used to check codes generated in the near past.
// You can use this value to tune how far you're willing to go.
for (int i = -window_size; i <= window_size; ++i) {
long hash;
try {
hash = verifyCode(decodedKey, t + i);
}catch (Exception e) {
// Yes, this is bad form - but
// the exceptions thrown would be rare and a static configuration problem
e.printStackTrace();
throw new RuntimeException(e.getMessage());
//return false;
}
if (hash == code) {
return true;
}
}
// The validation code is invalid.
return false;
}
private static int verifyCode(byte[] key, long t) throws NoSuchAlgorithmException, InvalidKeyException {
byte[] data = new byte[8];
long value = t;
for (int i = 8; i-- > 0; value >>>= 8) {
data[i] = (byte) value;
}
SecretKeySpec signKey = new SecretKeySpec(key, "HmacSHA1");
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(signKey);
byte[] hash = mac.doFinal(data);
int offset = hash[20 - 1] & 0xF;
// We're using a long because Java hasn't got unsigned int.
long truncatedHash = 0;
for (int i = 0; i < 4; ++i) {
truncatedHash <<= 8;
// We are dealing with signed bytes:
// we just keep the first byte.
truncatedHash |= (hash[offset + i] & 0xFF);
}
truncatedHash &= 0x7FFFFFFF;
truncatedHash %= 1000000;
return (int) truncatedHash;
}
}
| true |
15526_2 | package com.bie.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ResourceBundle;
/***
* 1.1：写DbUtils的工具类
* :utils是工具类，方便以后调用
* 在main方法测试的时候出现一个错误，
* 瞄了一眼立马想到了没有添加mysql的驱动，
* 所以我感觉测试还是很有必要的
* @author biehongli
*
*/
public class DbUtils {
private static String drivername;//数据库驱动，为了加载数据库驱动
private static String url;//数据库连接字符串，只要是找到自己的数据库，需要和自己的数据库一致
private static String user;//数据库账号，需要和自己的一致
private static String password;//数据库密码，需要和自己的一致
static{
drivername=ResourceBundle.getBundle("db").getString("drivername");
url=ResourceBundle.getBundle("db").getString("url");
user=ResourceBundle.getBundle("db").getString("user");
password=ResourceBundle.getBundle("db").getString("password");
}
/***
* 加载数据库驱动和连接到数据库，我一般是加载和连接的时候分别输出，可以快速找到哪里出错
* @return
* @throws Exception
*/
public static Connection getCon() throws Exception{
Class.forName(drivername);//记载数据库驱动
System.out.println("测试加载数据库驱动");
//连接到数据库
Connection con=DriverManager.getConnection(url, user, password);
System.out.println("测试连接到数据库");
return con;
}
/***
* 这个用来判断关闭数据库的方法
* @param con 关闭Connection的连接
* @param ps 关闭PreparedStatement
* @param rs 关闭ResultSet
*/
public static void getClose(Connection con,PreparedStatement ps,ResultSet rs){
//关闭数据库，注意关闭的顺序。养成好习惯
try{
if(rs!=null){
rs.close();
}
if(ps!=null){
ps.close();
}
if(con!=null){
con.close();
}
}catch(Exception e){
e.printStackTrace();
}
}
/***
* 添加(插入)和更新(更改)可以提取公共的方法写在工具类中
* 删除一般使用伪删除，这样删除就是更新(更改)操作，
* 所以只有查询(查找)需要写更多的代码
* @param sql 外面传来的sql语句
* @param arr 外面传来的数组类型的，是用户信息封装到集合传递进来
* @return 返回的是一个整形的数据类型
*/
public static int addAndUpdate(String sql,Object[] arr){
Connection con=null;
PreparedStatement ps=null;
try{
con=DbUtils.getCon();//第一步连接数据库
ps=con.prepareStatement(sql);//第二步预编译
//第三步给sql语句中的参数复制
for(int i=0;i<arr.length;i++){
ps.setObject(i+1, arr[i]);
}
//第四步执行sql并且返回。
return ps.executeUpdate();
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭资源，如果没有ResultSet类型的，加上null即可
DbUtils.getClose(con, ps, null);
}
return 0;
}
public static void main(String[] args) {
//我一般在写好连接数据库的工具类时先测试一下，避免连接数据库都失败，测试后可注释即可
try {
DbUtils.getCon();
System.out.println("测试连接数据库终极版！！！");
} catch (Exception e) {
e.printStackTrace();
}
}
}
| MRbie/book | src/com/bie/utils/DbUtils.java | 936 | //数据库连接字符串，只要是找到自己的数据库，需要和自己的数据库一致
| line_comment | zh-cn | package com.bie.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ResourceBundle;
/***
* 1.1：写DbUtils的工具类
* :utils是工具类，方便以后调用
* 在main方法测试的时候出现一个错误，
* 瞄了一眼立马想到了没有添加mysql的驱动，
* 所以我感觉测试还是很有必要的
* @author biehongli
*
*/
public class DbUtils {
private static String drivername;//数据库驱动，为了加载数据库驱动
private static String url;//数据 <SUF>
private static String user;//数据库账号，需要和自己的一致
private static String password;//数据库密码，需要和自己的一致
static{
drivername=ResourceBundle.getBundle("db").getString("drivername");
url=ResourceBundle.getBundle("db").getString("url");
user=ResourceBundle.getBundle("db").getString("user");
password=ResourceBundle.getBundle("db").getString("password");
}
/***
* 加载数据库驱动和连接到数据库，我一般是加载和连接的时候分别输出，可以快速找到哪里出错
* @return
* @throws Exception
*/
public static Connection getCon() throws Exception{
Class.forName(drivername);//记载数据库驱动
System.out.println("测试加载数据库驱动");
//连接到数据库
Connection con=DriverManager.getConnection(url, user, password);
System.out.println("测试连接到数据库");
return con;
}
/***
* 这个用来判断关闭数据库的方法
* @param con 关闭Connection的连接
* @param ps 关闭PreparedStatement
* @param rs 关闭ResultSet
*/
public static void getClose(Connection con,PreparedStatement ps,ResultSet rs){
//关闭数据库，注意关闭的顺序。养成好习惯
try{
if(rs!=null){
rs.close();
}
if(ps!=null){
ps.close();
}
if(con!=null){
con.close();
}
}catch(Exception e){
e.printStackTrace();
}
}
/***
* 添加(插入)和更新(更改)可以提取公共的方法写在工具类中
* 删除一般使用伪删除，这样删除就是更新(更改)操作，
* 所以只有查询(查找)需要写更多的代码
* @param sql 外面传来的sql语句
* @param arr 外面传来的数组类型的，是用户信息封装到集合传递进来
* @return 返回的是一个整形的数据类型
*/
public static int addAndUpdate(String sql,Object[] arr){
Connection con=null;
PreparedStatement ps=null;
try{
con=DbUtils.getCon();//第一步连接数据库
ps=con.prepareStatement(sql);//第二步预编译
//第三步给sql语句中的参数复制
for(int i=0;i<arr.length;i++){
ps.setObject(i+1, arr[i]);
}
//第四步执行sql并且返回。
return ps.executeUpdate();
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭资源，如果没有ResultSet类型的，加上null即可
DbUtils.getClose(con, ps, null);
}
return 0;
}
public static void main(String[] args) {
//我一般在写好连接数据库的工具类时先测试一下，避免连接数据库都失败，测试后可注释即可
try {
DbUtils.getCon();
System.out.println("测试连接数据库终极版！！！");
} catch (Exception e) {
e.printStackTrace();
}
}
}
| true |
34728_31 | package com.demo1.client.view;
import com.demo1.client.comman.*;
import com.demo1.client.model.*;
import com.demo1.client.tools.Judge;
import com.demo1.client.tools.MapClientConServerThread;
import com.demo1.client.tools.MapUserModel;
import org.apache.log4j.Logger;
import javax.swing.*;
import java.awt.event.MouseEvent;
import java.io.ObjectOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 加载人机棋盘
* 人机对战
*
* @author：admin
*/
public class PCChessBoard extends ChessBoard {
private int role; //人类角色
private PCMainBoard mb;//定义主界面
private Computer com;//定义电脑角色
private int step[][] = new int[30 * 30][2];//定义储存步数数组
private int stepCount = 0;//初始化数组
private Coord coord = new Coord(); //坐标
private User u;
//打印日志
private Logger logger1 = Logger.getLogger("棋盘");
private Logger logger2 = Logger.getLogger("接收通道");
public PCChessBoard(PCMainBoard mb) {
this.mb = mb;
this.u = mb.u;
role = Chess.WHITE; //定义玩家执白
com = new Computer();//加载电脑算法
}
/**
* 保存黑白棋子的坐标于二维数组中
*
* @param posX
* @param posY
*/
private void saveStep(int posX, int posY) {
stepCount++;
step[stepCount][0] = posX;
step[stepCount][1] = posY;
}
/**
* 悔棋，去掉刚下的黑白两棋
* chessCount - 2
*/
public void backstep() {
if (stepCount >= 2) {
chess[step[stepCount][0]][step[stepCount][1]] = 0; //撤销电脑下的棋子
chess[step[stepCount - 1][0]][step[stepCount - 1][1]] = 0; //撤销玩家下的棋子
stepCount = stepCount - 2;
savePreChess(step[stepCount][0], step[stepCount][1]); //重新标识最新的一步棋
rounds--;
}
}
/**
* 胜利事件
*
* @param winner 胜利方
**/
public void WinEvent(int winner) {
//白棋或黑棋赢时
if(winner == Chess.WHITE || winner == Chess.BLACK){
reStartInit(winner); //游戏结束，重新初始化
}
//出现游戏和棋的局面
else if(isGameDraw()){
reStartInit(winner); //游戏结束，重新初始化
}
}
//游戏正常结束，保存记录，重新初始化
public void reStartInit(int winner){
gameOver = true;
try {
mb.getTimer().interrupt(); //中断线程
} catch (Exception e1) {
e1.printStackTrace();
}
/*恢复初始页面状态*/
mb.getStart().setText("开始游戏");
mb.getStart().setEnabled(true);
mb.getRestart().setEnabled(false);
mb.getSituation1().setText(" 状态:");
mb.getSituation2().setText(" 状态:");
//保存对战记录
GradeRecord gr = new GradeRecord();
//获取当前系统时间
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String time = df.format(new Date()).toString();
this.model = MapUserModel.getModel(u.getName());
gr.setUserName(u.getName());
gr.setRivalName("电脑");
gr.setRounds(rounds);
gr.setTime(time);
gr.setUserLevel(u.getDan()+"-"+u.getGrade());
//设置对战记录中的模式
if(model == MapUserModel.VERSUS){
gr.setModel("对弈");
} else {
gr.setModel("训练");
}
int level = mb.getLevel();
//设置记录里的电脑水平
if(level == SelectLevel.PRIMARY){
gr.setRivalLevel("初级");
}
else if(level == SelectLevel.MEDIUM){
gr.setRivalLevel("中级");
} else if(level == SelectLevel.SENIOR){
gr.setRivalLevel("高级");
}
//黑棋赢
if(winner == Chess.BLACK){
//电脑获胜
gr.setWin("负");
if(model == MapUserModel.VERSUS){
//对弈模式下玩家段位可以上升，训练模式下无论输赢段位都不改变
//电脑为初级时
if(level == SelectLevel.PRIMARY){
//输给初级电脑连降2级
u.degrade(2);
}
else if(level == SelectLevel.MEDIUM){
//输给中级电脑降1级
u.degrade(1);
} else if(level == SelectLevel.SENIOR){
//输给高级电脑降1级
u.upgrade(2);
}
}
if(mb.getTimer().isTimeOver()){
JOptionPane.showMessageDialog(mb, "超过时间限制，电脑(黑棋)获胜！\n共 " + rounds + " 个回合，很遗憾，你输了~");
} else {
JOptionPane.showMessageDialog(mb, "电脑(黑棋)获胜！\n共 " + rounds + " 个回合，很遗憾，你输了~");
}
logger1.info("黑棋获胜！初始化棋盘页面");
}
//白棋赢（玩家获胜）
else if(winner == Chess.WHITE){
gr.setWin("胜");
//对弈模式下玩家段位可以上升，训练模式下无论输赢段位都不改变
if(model == MapUserModel.VERSUS) {
//电脑为初级时
if (level == SelectLevel.PRIMARY) {
//初级太简单了，不升级
} else if (level == SelectLevel.MEDIUM) {
//赢了中级电脑升1级
u.upgrade(1);
} else if (level == SelectLevel.SENIOR) {
//赢了高级电脑升2级
u.upgrade(2);
}
}
JOptionPane.showMessageDialog(mb, "恭喜！白棋获胜\n共 "+rounds+" 个回合, 你赢了~");
logger1.info("白棋获胜！初始化棋盘页面");
}
//和棋
else {
gr.setWin("和");
JOptionPane.showMessageDialog(mb, "平分秋色，和棋~\n共 "+rounds+" 个回合");
}
//更新数据
mb.setU(u);
//更新用户等级标签
mb.getPlv().setText(" 等 级: "+u.getDan()+"-"+u.getGrade());
//通过通信线程向服务器发送消息包，请求保存对战记录和更新用户等级
Message m = new Message();
//设置消息包类型
m.setMesType(MessageType.UPDATE_GRADE);
m.setU(u);
m.setGr(gr);
try {
//获取客户端到服务器的通信线程
ObjectOutputStream oos = new ObjectOutputStream
(MapClientConServerThread.getClientConnServerThread(u.getName()).getS().getOutputStream());
//通过对象流发送消息包
oos.writeObject(m);
} catch (Exception e) {
e.printStackTrace();
}
//更新MapUserModel里User的数据
MapUserModel.addUser(u.getName(), u);
setClickable(MainBoard.CAN_NOT_CLICK_INFO);
initArray(); //初始化页面
rounds = 0; //重置chessCount
mb.getLabel().setText(null); //清空计时
//刷新用户等级
String title = "欢乐五子棋--当前用户：" + u.getName() + "(" + u.getSex() + ")" + " 等级：" + u.getDan() + "-" + u.getGrade();
mb.setTitle(title);
//设置悔棋和认输不可用
mb.getBack().setEnabled(false);
mb.getGiveUp().setEnabled(false);
}
/**
* 提前结束游戏（没有胜负），重置游戏
* */
public void gameRestart(){
gameOver = true;
try{
mb.getTimer().interrupt();
} catch (Exception e){
e.printStackTrace();
}
/*恢复初始页面状态*/
mb.getStart().setText("开始游戏");
mb.getSituation1().setText(" 状态:");
mb.getSituation2().setText(" 状态:");
initArray(); //初始化数据
rounds = 0; //初始化棋子个数
}
/**
* 落子算法
* 判断落子是否合法
* @param e
**/
@Override
public void mouseClicked(MouseEvent e) {
int winner;
if (clickable == MainBoard.CAN_CLICK_INFO) {
//获取落子的坐标
chessX = e.getX();
chessY = e.getY();
//将点击限制在棋盘内
if (chessX < 524 && chessX > 50 && chessY < 523 && chessY > 50) {
//计算出要贴图的坐标
float x = (chessX - 49) / 25;
float y = (chessY - 50) / 25;
int x1 = (int) x;
int y1 = (int) y;
//如果这个地方没有棋子
if (chess[x1][y1] == Chess.BLANK) {
chess[x1][y1] = role;
try {
mb.getTimer().interrupt();
} catch (Exception e1) {
e1.printStackTrace();
}
mb.getSituation1().setText(" 状态:下棋...");
mb.getSituation2().setText(" 状态:等待...");
logger2.info("等待对方消息");
savePreChess(x1, y1); //保存最新下的棋子的坐标，用于画红色标识方框
saveStep(x1, y1); //保存坐标，用于悔棋
rounds++; //棋子总数+1
logger1.info("白棋落子:" + x1 + "," + y1);
setClickable(MainBoard.CAN_NOT_CLICK_INFO);
winner = Judge.whowin(x1, y1, chess, role);//判断胜负
WinEvent(winner);
if (!gameOver) {
coord = com.computePos(Chess.BLACK, chess, mb.getLevel());//加载电脑棋类算法
chess[coord.getX()][coord.getY()] = Chess.BLACK;//输出黑棋图片
//重新启动计时线程
mb.timer = new TimeThread(mb.getLabel());
mb.timer.setPCChessBoard(this);
mb.timer.start();
logger1.info("黑棋落子:" + coord.getX() + "," + coord.getY());
mb.getSituation1().setText(" 状态:等待...");
logger2.info("等待对方消息");
mb.getSituation2().setText(" 状态:下棋...");
saveStep(coord.getX(), coord.getY()); //保存电脑坐标，用于悔棋
savePreChess(coord.getX(), coord.getY()); //保存电脑坐标，用于红框标识
winner = Judge.whowin(coord.getX(), coord.getY(), chess, Chess.BLACK);
WinEvent(winner);
if (!gameOver) {
setClickable(MainBoard.CAN_CLICK_INFO);
}
}
}
}
}
}
/**
* 鼠标点击事件
*
* @param e
**/
@Override
public void mouseMoved(MouseEvent e) {
if (clickable == MainBoard.CAN_CLICK_INFO) {
//获得鼠标点击的坐标
mousex = e.getX();
mousey = e.getY();
//重新绘图
repaint();
}
}
}
| MSJeinlong/Gobang_Net | src/com/demo1/client/view/PCChessBoard.java | 2,956 | //输给初级电脑连降2级 | line_comment | zh-cn | package com.demo1.client.view;
import com.demo1.client.comman.*;
import com.demo1.client.model.*;
import com.demo1.client.tools.Judge;
import com.demo1.client.tools.MapClientConServerThread;
import com.demo1.client.tools.MapUserModel;
import org.apache.log4j.Logger;
import javax.swing.*;
import java.awt.event.MouseEvent;
import java.io.ObjectOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 加载人机棋盘
* 人机对战
*
* @author：admin
*/
public class PCChessBoard extends ChessBoard {
private int role; //人类角色
private PCMainBoard mb;//定义主界面
private Computer com;//定义电脑角色
private int step[][] = new int[30 * 30][2];//定义储存步数数组
private int stepCount = 0;//初始化数组
private Coord coord = new Coord(); //坐标
private User u;
//打印日志
private Logger logger1 = Logger.getLogger("棋盘");
private Logger logger2 = Logger.getLogger("接收通道");
public PCChessBoard(PCMainBoard mb) {
this.mb = mb;
this.u = mb.u;
role = Chess.WHITE; //定义玩家执白
com = new Computer();//加载电脑算法
}
/**
* 保存黑白棋子的坐标于二维数组中
*
* @param posX
* @param posY
*/
private void saveStep(int posX, int posY) {
stepCount++;
step[stepCount][0] = posX;
step[stepCount][1] = posY;
}
/**
* 悔棋，去掉刚下的黑白两棋
* chessCount - 2
*/
public void backstep() {
if (stepCount >= 2) {
chess[step[stepCount][0]][step[stepCount][1]] = 0; //撤销电脑下的棋子
chess[step[stepCount - 1][0]][step[stepCount - 1][1]] = 0; //撤销玩家下的棋子
stepCount = stepCount - 2;
savePreChess(step[stepCount][0], step[stepCount][1]); //重新标识最新的一步棋
rounds--;
}
}
/**
* 胜利事件
*
* @param winner 胜利方
**/
public void WinEvent(int winner) {
//白棋或黑棋赢时
if(winner == Chess.WHITE || winner == Chess.BLACK){
reStartInit(winner); //游戏结束，重新初始化
}
//出现游戏和棋的局面
else if(isGameDraw()){
reStartInit(winner); //游戏结束，重新初始化
}
}
//游戏正常结束，保存记录，重新初始化
public void reStartInit(int winner){
gameOver = true;
try {
mb.getTimer().interrupt(); //中断线程
} catch (Exception e1) {
e1.printStackTrace();
}
/*恢复初始页面状态*/
mb.getStart().setText("开始游戏");
mb.getStart().setEnabled(true);
mb.getRestart().setEnabled(false);
mb.getSituation1().setText(" 状态:");
mb.getSituation2().setText(" 状态:");
//保存对战记录
GradeRecord gr = new GradeRecord();
//获取当前系统时间
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
String time = df.format(new Date()).toString();
this.model = MapUserModel.getModel(u.getName());
gr.setUserName(u.getName());
gr.setRivalName("电脑");
gr.setRounds(rounds);
gr.setTime(time);
gr.setUserLevel(u.getDan()+"-"+u.getGrade());
//设置对战记录中的模式
if(model == MapUserModel.VERSUS){
gr.setModel("对弈");
} else {
gr.setModel("训练");
}
int level = mb.getLevel();
//设置记录里的电脑水平
if(level == SelectLevel.PRIMARY){
gr.setRivalLevel("初级");
}
else if(level == SelectLevel.MEDIUM){
gr.setRivalLevel("中级");
} else if(level == SelectLevel.SENIOR){
gr.setRivalLevel("高级");
}
//黑棋赢
if(winner == Chess.BLACK){
//电脑获胜
gr.setWin("负");
if(model == MapUserModel.VERSUS){
//对弈模式下玩家段位可以上升，训练模式下无论输赢段位都不改变
//电脑为初级时
if(level == SelectLevel.PRIMARY){
//输给 <SUF>
u.degrade(2);
}
else if(level == SelectLevel.MEDIUM){
//输给中级电脑降1级
u.degrade(1);
} else if(level == SelectLevel.SENIOR){
//输给高级电脑降1级
u.upgrade(2);
}
}
if(mb.getTimer().isTimeOver()){
JOptionPane.showMessageDialog(mb, "超过时间限制，电脑(黑棋)获胜！\n共 " + rounds + " 个回合，很遗憾，你输了~");
} else {
JOptionPane.showMessageDialog(mb, "电脑(黑棋)获胜！\n共 " + rounds + " 个回合，很遗憾，你输了~");
}
logger1.info("黑棋获胜！初始化棋盘页面");
}
//白棋赢（玩家获胜）
else if(winner == Chess.WHITE){
gr.setWin("胜");
//对弈模式下玩家段位可以上升，训练模式下无论输赢段位都不改变
if(model == MapUserModel.VERSUS) {
//电脑为初级时
if (level == SelectLevel.PRIMARY) {
//初级太简单了，不升级
} else if (level == SelectLevel.MEDIUM) {
//赢了中级电脑升1级
u.upgrade(1);
} else if (level == SelectLevel.SENIOR) {
//赢了高级电脑升2级
u.upgrade(2);
}
}
JOptionPane.showMessageDialog(mb, "恭喜！白棋获胜\n共 "+rounds+" 个回合, 你赢了~");
logger1.info("白棋获胜！初始化棋盘页面");
}
//和棋
else {
gr.setWin("和");
JOptionPane.showMessageDialog(mb, "平分秋色，和棋~\n共 "+rounds+" 个回合");
}
//更新数据
mb.setU(u);
//更新用户等级标签
mb.getPlv().setText(" 等 级: "+u.getDan()+"-"+u.getGrade());
//通过通信线程向服务器发送消息包，请求保存对战记录和更新用户等级
Message m = new Message();
//设置消息包类型
m.setMesType(MessageType.UPDATE_GRADE);
m.setU(u);
m.setGr(gr);
try {
//获取客户端到服务器的通信线程
ObjectOutputStream oos = new ObjectOutputStream
(MapClientConServerThread.getClientConnServerThread(u.getName()).getS().getOutputStream());
//通过对象流发送消息包
oos.writeObject(m);
} catch (Exception e) {
e.printStackTrace();
}
//更新MapUserModel里User的数据
MapUserModel.addUser(u.getName(), u);
setClickable(MainBoard.CAN_NOT_CLICK_INFO);
initArray(); //初始化页面
rounds = 0; //重置chessCount
mb.getLabel().setText(null); //清空计时
//刷新用户等级
String title = "欢乐五子棋--当前用户：" + u.getName() + "(" + u.getSex() + ")" + " 等级：" + u.getDan() + "-" + u.getGrade();
mb.setTitle(title);
//设置悔棋和认输不可用
mb.getBack().setEnabled(false);
mb.getGiveUp().setEnabled(false);
}
/**
* 提前结束游戏（没有胜负），重置游戏
* */
public void gameRestart(){
gameOver = true;
try{
mb.getTimer().interrupt();
} catch (Exception e){
e.printStackTrace();
}
/*恢复初始页面状态*/
mb.getStart().setText("开始游戏");
mb.getSituation1().setText(" 状态:");
mb.getSituation2().setText(" 状态:");
initArray(); //初始化数据
rounds = 0; //初始化棋子个数
}
/**
* 落子算法
* 判断落子是否合法
* @param e
**/
@Override
public void mouseClicked(MouseEvent e) {
int winner;
if (clickable == MainBoard.CAN_CLICK_INFO) {
//获取落子的坐标
chessX = e.getX();
chessY = e.getY();
//将点击限制在棋盘内
if (chessX < 524 && chessX > 50 && chessY < 523 && chessY > 50) {
//计算出要贴图的坐标
float x = (chessX - 49) / 25;
float y = (chessY - 50) / 25;
int x1 = (int) x;
int y1 = (int) y;
//如果这个地方没有棋子
if (chess[x1][y1] == Chess.BLANK) {
chess[x1][y1] = role;
try {
mb.getTimer().interrupt();
} catch (Exception e1) {
e1.printStackTrace();
}
mb.getSituation1().setText(" 状态:下棋...");
mb.getSituation2().setText(" 状态:等待...");
logger2.info("等待对方消息");
savePreChess(x1, y1); //保存最新下的棋子的坐标，用于画红色标识方框
saveStep(x1, y1); //保存坐标，用于悔棋
rounds++; //棋子总数+1
logger1.info("白棋落子:" + x1 + "," + y1);
setClickable(MainBoard.CAN_NOT_CLICK_INFO);
winner = Judge.whowin(x1, y1, chess, role);//判断胜负
WinEvent(winner);
if (!gameOver) {
coord = com.computePos(Chess.BLACK, chess, mb.getLevel());//加载电脑棋类算法
chess[coord.getX()][coord.getY()] = Chess.BLACK;//输出黑棋图片
//重新启动计时线程
mb.timer = new TimeThread(mb.getLabel());
mb.timer.setPCChessBoard(this);
mb.timer.start();
logger1.info("黑棋落子:" + coord.getX() + "," + coord.getY());
mb.getSituation1().setText(" 状态:等待...");
logger2.info("等待对方消息");
mb.getSituation2().setText(" 状态:下棋...");
saveStep(coord.getX(), coord.getY()); //保存电脑坐标，用于悔棋
savePreChess(coord.getX(), coord.getY()); //保存电脑坐标，用于红框标识
winner = Judge.whowin(coord.getX(), coord.getY(), chess, Chess.BLACK);
WinEvent(winner);
if (!gameOver) {
setClickable(MainBoard.CAN_CLICK_INFO);
}
}
}
}
}
}
/**
* 鼠标点击事件
*
* @param e
**/
@Override
public void mouseMoved(MouseEvent e) {
if (clickable == MainBoard.CAN_CLICK_INFO) {
//获得鼠标点击的坐标
mousex = e.getX();
mousey = e.getY();
//重新绘图
repaint();
}
}
}
| true |
64989_37 | package com.demo1.view;
import com.demo1.model.TimeThread;
import com.demo1.net.NetTool;
import org.apache.log4j.Logger;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* 人人对战页面
* 接收信息线程
*
* @author admin
*/
public class PPMainBoard extends MainBoard {
private PPChessBoard cb;
private JButton startGame;
private JButton exitGame;
private JButton back;//悔棋按钮
private JButton send; //聊天发送按钮
private JLabel timecount;//计时器标签
//双方状态
private JLabel people1;//自己标签
private JLabel people2;//对手标签
private JLabel p1lv;//自己等级标签
private JLabel p2lv;//对手等级标签
private JLabel situation1;//自己状态标签
private JLabel situation2;//对手状态标签
private JLabel jLabel1;
private JLabel jLabel2;//
private JTextArea talkArea;
private JTextField tf_ip; //输入IP框
private JTextField talkField; //聊天文本框
private String ip;
private DatagramSocket socket;
private String gameState;
private String enemyGameState;//敌人状态
private Logger logger = Logger.getLogger("游戏");
public JButton getstart() {
return startGame;
}
public String getIp() {
return ip;
}
public JTextField getTf() {
return tf_ip;
}
public DatagramSocket getSocket() {
return socket;
}
public JLabel getLabel1() {
return jLabel1;
}
public JLabel getLabel2() {
return jLabel2;
}
public JLabel getSituation1() {
return situation1;
}
public JLabel getSituation2() {
return situation2;
}
public PPMainBoard() {
init();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
/**
* 初始化页面
*/
public void init() {
gameState = "NOT_START";
enemyGameState = "NOT_START";
cb = new PPChessBoard(this);
cb.setClickable(PPMainBoard.CAN_NOT_CLICK_INFO);
cb.setBounds(210, 40, 570, 585);
cb.setVisible(true);
cb.setInfoBoard(talkArea);
tf_ip = new JTextField("请输入对手IP地址");
tf_ip.setBounds(780, 75, 200, 30);
tf_ip.addMouseListener(this);
startGame = new JButton("准备游戏");//设置名称，下同
startGame.setBounds(780, 130, 200, 50);//设置起始位置，宽度和高度，下同
startGame.setBackground(new Color(50, 205, 50));//设置颜色，下同
startGame.setFont(new Font("宋体", Font.BOLD, 20));//设置字体，下同
startGame.addActionListener(this);
back = new JButton("悔 棋");
back.setBounds(780, 185, 200, 50);
back.setBackground(new Color(85, 107, 47));
back.setFont(new Font("宋体", Font.BOLD, 20));
back.addActionListener(this);
send = new JButton("发送");
send.setBounds(840, 550, 60, 30);
send.setBackground(new Color(50, 205, 50));
send.addActionListener(this);
talkField = new JTextField("聊天");
talkField.setBounds(780, 510, 200, 30);
talkField.addMouseListener(this);
exitGame = new JButton("返 回");
exitGame.setBackground(new Color(218, 165, 32));
exitGame.setBounds(780, 240, 200, 50);
exitGame.setFont(new Font("宋体", Font.BOLD, 20));//设置字体，下同
exitGame.addActionListener(this);
people1 = new JLabel(" 我:");
people1.setOpaque(true);
people1.setBackground(new Color(82, 109, 165));
people1.setBounds(10, 410, 200, 50);
people1.setFont(new Font("宋体", Font.BOLD, 20));
people2 = new JLabel(" 对手:");
people2.setOpaque(true);
people2.setBackground(new Color(82, 109, 165));
people2.setBounds(10, 75, 200, 50);
people2.setFont(new Font("宋体", Font.BOLD, 20));
timecount = new JLabel(" 计时器:");
timecount.setBounds(320, 1, 200, 50);
timecount.setFont(new Font("宋体", Font.BOLD, 30));
p1lv = new JLabel(" 等 级:LV.1");
p1lv.setOpaque(true);
p1lv.setBackground(new Color(82, 109, 165));
p1lv.setBounds(10, 130, 200, 50);
p1lv.setFont(new Font("宋体", Font.BOLD, 20));
p2lv = new JLabel(" 等 级:LV.1");
p2lv.setOpaque(true);
p2lv.setBackground(new Color(82, 109, 165));
p2lv.setBounds(10, 465, 200, 50);
p2lv.setFont(new Font("宋体", Font.BOLD, 20));
situation1 = new JLabel(" 状态:");
situation1.setOpaque(true);
situation1.setBackground(new Color(82, 109, 165));
situation1.setBounds(10, 185, 200, 50);
situation1.setFont(new Font("宋体", Font.BOLD, 20));
situation2 = new JLabel(" 状态:");
situation2.setOpaque(true);
situation2.setBackground(new Color(82, 109, 165));
situation2.setBounds(10, 520, 200, 50);
situation2.setFont(new Font("宋体", Font.BOLD, 20));
jLabel1 = new JLabel();
add(jLabel1);
jLabel1.setBounds(130, 75, 200, 50);
jLabel2 = new JLabel();
add(jLabel2);
jLabel2.setBounds(130, 410, 200, 50);
timecount = new JLabel(" 计时器:");
timecount.setBounds(320, 1, 200, 50);
timecount.setFont(new Font("宋体", Font.BOLD, 30));
talkArea = new JTextArea(); //对弈信息
talkArea.setEnabled(false);
talkArea.setBackground(Color.BLUE);
//滑动条
JScrollPane p = new JScrollPane(talkArea);
p.setBounds(780, 295, 200, 200);
add(tf_ip);
add(cb);
add(startGame);
add(back);
add(exitGame);
add(people1);
add(people2);
add(p1lv);
add(p2lv);
add(situation1);
add(situation2);
add(timecount);
add(p);
add(send);
add(talkField);
//加载线程
ReicThread();
repaint();
}
/**
* 接收信息放在线程中
*/
public void ReicThread() {
new Thread(new Runnable() {
public void run() {
try {
byte buf[] = new byte[1024];
socket = new DatagramSocket(10086);
DatagramPacket dp = new DatagramPacket(buf, buf.length);
while (true) {
socket.receive(dp);
//0.接收到的发送端的主机名
InetAddress ia = dp.getAddress();
//enemyMsg.add(new String(ia.getHostName())); //对方端口
logger.info("对手IP：" + ia.getHostName());
//1.接收到的内容
String data = new String(dp.getData(), 0, dp.getLength());
if (data.isEmpty()) {
cb.setClickable(MainBoard.CAN_NOT_CLICK_INFO);
} else {
String[] msg = data.split(",");
System.out.println(msg[0] + " " + msg[1]);
//接收到对面准备信息并且自己点击了准备
if (msg[0].equals("ready")) {
enemyGameState = "ready";
System.out.println("对方已准备");
if (gameState.equals("ready")) {
gameState = "FIGHTING";
cb.setClickable(MainBoard.CAN_CLICK_INFO);
startGame.setText("正在游戏");
situation1.setText(" 状态:等待...");
situation2.setText(" 状态:下棋...");
logger.info("等待对方消息");
timer = new TimeThread(label_timeCount);
timer.start();
}
} else if (msg[0].equals("POS")) {
System.out.println("发送坐标");
//接受坐标以及角色
situation1.setText(" 状态:等待...");
situation2.setText(" 状态:下棋...");
//重新启动计时线程
timer = new TimeThread(label_timeCount);
timer.start();
cb.setCoord(Integer.parseInt(msg[1]), Integer.parseInt(msg[2]), Integer.parseInt(msg[3]));
} else if (msg[0].equals("enemy")) {
talkArea.append("对手：" + msg[1] + "\n");
logger.info("对手发送的消息" + msg[1]);
} else if (msg[0].equals("back")) {
int n = JOptionPane.showConfirmDialog(cb, "是否同意对方悔棋", "选择", JOptionPane.YES_NO_OPTION);
//点击确定按钮则可以悔棋
if (n == JOptionPane.YES_OPTION) {
cb.backstep();
NetTool.sendUDPBroadCast(ia.getHostName(), "canBack" + ", ");
} else {
NetTool.sendUDPBroadCast(ia.getHostName(), "noBack" + ", ");
}
}
//允许悔棋
else if (msg[0].equals("canBack")) {
JOptionPane.showMessageDialog(cb, "对方允许您悔棋");
cb.backstep();
}
//不允许悔棋
else if (msg[0].equals("noBack")) {
JOptionPane.showMessageDialog(cb, "对方不允许您悔棋");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == startGame) {
if (!tf_ip.getText().isEmpty() &&
!tf_ip.getText().equals("不能为空") &&
!tf_ip.getText().equals("请输入IP地址") &&
!tf_ip.getText().equals("不能连接到此IP")) {
ip = tf_ip.getText();
startGame.setEnabled(false);
startGame.setText("等待对方准备");
tf_ip.setEditable(false);
//发送准备好信息
NetTool.sendUDPBroadCast(ip, "ready, ");
gameState = "ready";
if (enemyGameState == "ready") {
gameState = "FIGHTING";
cb.setClickable(CAN_CLICK_INFO);
startGame.setText("正在游戏");
situation1.setText(" 状态:等待...");
situation2.setText(" 状态:下棋...");
timer = new TimeThread(label_timeCount);
timer.start();
}
} else {
tf_ip.setText("不能为空");
}
}
//点击悔棋后的操作
else if (e.getSource() == back) {
//发送悔棋信息
NetTool.sendUDPBroadCast(ip, "back" + ", ");
logger.info("玩家选择悔棋");
}
// 聊天发送按钮
else if (e.getSource() == send) {
if (!talkField.getText().isEmpty() && !talkField.getText().equals("不能为空")) {
//获得输入的内容
String msg = talkField.getText();
talkArea.append("我：" + msg + "\n");
talkField.setText("");
ip = tf_ip.getText();
NetTool.sendUDPBroadCast(ip, "enemy" + "," + msg);
} else {
talkField.setText("不能为空");
}
}
//退出游戏，加载主菜单
else if (e.getSource() == exitGame) {
dispose();
new SelectModel();
}
}
@Override
public void mouseClicked(MouseEvent e) {
if (e.getSource() == tf_ip) {
tf_ip.setText("");
} else if (e.getSource() == talkField) {
talkField.setText("");
}
}
}
| MSJeinlong/JavaSE_Gobang | src/com/demo1/view/PPMainBoard.java | 3,229 | //获得输入的内容 | line_comment | zh-cn | package com.demo1.view;
import com.demo1.model.TimeThread;
import com.demo1.net.NetTool;
import org.apache.log4j.Logger;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* 人人对战页面
* 接收信息线程
*
* @author admin
*/
public class PPMainBoard extends MainBoard {
private PPChessBoard cb;
private JButton startGame;
private JButton exitGame;
private JButton back;//悔棋按钮
private JButton send; //聊天发送按钮
private JLabel timecount;//计时器标签
//双方状态
private JLabel people1;//自己标签
private JLabel people2;//对手标签
private JLabel p1lv;//自己等级标签
private JLabel p2lv;//对手等级标签
private JLabel situation1;//自己状态标签
private JLabel situation2;//对手状态标签
private JLabel jLabel1;
private JLabel jLabel2;//
private JTextArea talkArea;
private JTextField tf_ip; //输入IP框
private JTextField talkField; //聊天文本框
private String ip;
private DatagramSocket socket;
private String gameState;
private String enemyGameState;//敌人状态
private Logger logger = Logger.getLogger("游戏");
public JButton getstart() {
return startGame;
}
public String getIp() {
return ip;
}
public JTextField getTf() {
return tf_ip;
}
public DatagramSocket getSocket() {
return socket;
}
public JLabel getLabel1() {
return jLabel1;
}
public JLabel getLabel2() {
return jLabel2;
}
public JLabel getSituation1() {
return situation1;
}
public JLabel getSituation2() {
return situation2;
}
public PPMainBoard() {
init();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
/**
* 初始化页面
*/
public void init() {
gameState = "NOT_START";
enemyGameState = "NOT_START";
cb = new PPChessBoard(this);
cb.setClickable(PPMainBoard.CAN_NOT_CLICK_INFO);
cb.setBounds(210, 40, 570, 585);
cb.setVisible(true);
cb.setInfoBoard(talkArea);
tf_ip = new JTextField("请输入对手IP地址");
tf_ip.setBounds(780, 75, 200, 30);
tf_ip.addMouseListener(this);
startGame = new JButton("准备游戏");//设置名称，下同
startGame.setBounds(780, 130, 200, 50);//设置起始位置，宽度和高度，下同
startGame.setBackground(new Color(50, 205, 50));//设置颜色，下同
startGame.setFont(new Font("宋体", Font.BOLD, 20));//设置字体，下同
startGame.addActionListener(this);
back = new JButton("悔 棋");
back.setBounds(780, 185, 200, 50);
back.setBackground(new Color(85, 107, 47));
back.setFont(new Font("宋体", Font.BOLD, 20));
back.addActionListener(this);
send = new JButton("发送");
send.setBounds(840, 550, 60, 30);
send.setBackground(new Color(50, 205, 50));
send.addActionListener(this);
talkField = new JTextField("聊天");
talkField.setBounds(780, 510, 200, 30);
talkField.addMouseListener(this);
exitGame = new JButton("返 回");
exitGame.setBackground(new Color(218, 165, 32));
exitGame.setBounds(780, 240, 200, 50);
exitGame.setFont(new Font("宋体", Font.BOLD, 20));//设置字体，下同
exitGame.addActionListener(this);
people1 = new JLabel(" 我:");
people1.setOpaque(true);
people1.setBackground(new Color(82, 109, 165));
people1.setBounds(10, 410, 200, 50);
people1.setFont(new Font("宋体", Font.BOLD, 20));
people2 = new JLabel(" 对手:");
people2.setOpaque(true);
people2.setBackground(new Color(82, 109, 165));
people2.setBounds(10, 75, 200, 50);
people2.setFont(new Font("宋体", Font.BOLD, 20));
timecount = new JLabel(" 计时器:");
timecount.setBounds(320, 1, 200, 50);
timecount.setFont(new Font("宋体", Font.BOLD, 30));
p1lv = new JLabel(" 等 级:LV.1");
p1lv.setOpaque(true);
p1lv.setBackground(new Color(82, 109, 165));
p1lv.setBounds(10, 130, 200, 50);
p1lv.setFont(new Font("宋体", Font.BOLD, 20));
p2lv = new JLabel(" 等 级:LV.1");
p2lv.setOpaque(true);
p2lv.setBackground(new Color(82, 109, 165));
p2lv.setBounds(10, 465, 200, 50);
p2lv.setFont(new Font("宋体", Font.BOLD, 20));
situation1 = new JLabel(" 状态:");
situation1.setOpaque(true);
situation1.setBackground(new Color(82, 109, 165));
situation1.setBounds(10, 185, 200, 50);
situation1.setFont(new Font("宋体", Font.BOLD, 20));
situation2 = new JLabel(" 状态:");
situation2.setOpaque(true);
situation2.setBackground(new Color(82, 109, 165));
situation2.setBounds(10, 520, 200, 50);
situation2.setFont(new Font("宋体", Font.BOLD, 20));
jLabel1 = new JLabel();
add(jLabel1);
jLabel1.setBounds(130, 75, 200, 50);
jLabel2 = new JLabel();
add(jLabel2);
jLabel2.setBounds(130, 410, 200, 50);
timecount = new JLabel(" 计时器:");
timecount.setBounds(320, 1, 200, 50);
timecount.setFont(new Font("宋体", Font.BOLD, 30));
talkArea = new JTextArea(); //对弈信息
talkArea.setEnabled(false);
talkArea.setBackground(Color.BLUE);
//滑动条
JScrollPane p = new JScrollPane(talkArea);
p.setBounds(780, 295, 200, 200);
add(tf_ip);
add(cb);
add(startGame);
add(back);
add(exitGame);
add(people1);
add(people2);
add(p1lv);
add(p2lv);
add(situation1);
add(situation2);
add(timecount);
add(p);
add(send);
add(talkField);
//加载线程
ReicThread();
repaint();
}
/**
* 接收信息放在线程中
*/
public void ReicThread() {
new Thread(new Runnable() {
public void run() {
try {
byte buf[] = new byte[1024];
socket = new DatagramSocket(10086);
DatagramPacket dp = new DatagramPacket(buf, buf.length);
while (true) {
socket.receive(dp);
//0.接收到的发送端的主机名
InetAddress ia = dp.getAddress();
//enemyMsg.add(new String(ia.getHostName())); //对方端口
logger.info("对手IP：" + ia.getHostName());
//1.接收到的内容
String data = new String(dp.getData(), 0, dp.getLength());
if (data.isEmpty()) {
cb.setClickable(MainBoard.CAN_NOT_CLICK_INFO);
} else {
String[] msg = data.split(",");
System.out.println(msg[0] + " " + msg[1]);
//接收到对面准备信息并且自己点击了准备
if (msg[0].equals("ready")) {
enemyGameState = "ready";
System.out.println("对方已准备");
if (gameState.equals("ready")) {
gameState = "FIGHTING";
cb.setClickable(MainBoard.CAN_CLICK_INFO);
startGame.setText("正在游戏");
situation1.setText(" 状态:等待...");
situation2.setText(" 状态:下棋...");
logger.info("等待对方消息");
timer = new TimeThread(label_timeCount);
timer.start();
}
} else if (msg[0].equals("POS")) {
System.out.println("发送坐标");
//接受坐标以及角色
situation1.setText(" 状态:等待...");
situation2.setText(" 状态:下棋...");
//重新启动计时线程
timer = new TimeThread(label_timeCount);
timer.start();
cb.setCoord(Integer.parseInt(msg[1]), Integer.parseInt(msg[2]), Integer.parseInt(msg[3]));
} else if (msg[0].equals("enemy")) {
talkArea.append("对手：" + msg[1] + "\n");
logger.info("对手发送的消息" + msg[1]);
} else if (msg[0].equals("back")) {
int n = JOptionPane.showConfirmDialog(cb, "是否同意对方悔棋", "选择", JOptionPane.YES_NO_OPTION);
//点击确定按钮则可以悔棋
if (n == JOptionPane.YES_OPTION) {
cb.backstep();
NetTool.sendUDPBroadCast(ia.getHostName(), "canBack" + ", ");
} else {
NetTool.sendUDPBroadCast(ia.getHostName(), "noBack" + ", ");
}
}
//允许悔棋
else if (msg[0].equals("canBack")) {
JOptionPane.showMessageDialog(cb, "对方允许您悔棋");
cb.backstep();
}
//不允许悔棋
else if (msg[0].equals("noBack")) {
JOptionPane.showMessageDialog(cb, "对方不允许您悔棋");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == startGame) {
if (!tf_ip.getText().isEmpty() &&
!tf_ip.getText().equals("不能为空") &&
!tf_ip.getText().equals("请输入IP地址") &&
!tf_ip.getText().equals("不能连接到此IP")) {
ip = tf_ip.getText();
startGame.setEnabled(false);
startGame.setText("等待对方准备");
tf_ip.setEditable(false);
//发送准备好信息
NetTool.sendUDPBroadCast(ip, "ready, ");
gameState = "ready";
if (enemyGameState == "ready") {
gameState = "FIGHTING";
cb.setClickable(CAN_CLICK_INFO);
startGame.setText("正在游戏");
situation1.setText(" 状态:等待...");
situation2.setText(" 状态:下棋...");
timer = new TimeThread(label_timeCount);
timer.start();
}
} else {
tf_ip.setText("不能为空");
}
}
//点击悔棋后的操作
else if (e.getSource() == back) {
//发送悔棋信息
NetTool.sendUDPBroadCast(ip, "back" + ", ");
logger.info("玩家选择悔棋");
}
// 聊天发送按钮
else if (e.getSource() == send) {
if (!talkField.getText().isEmpty() && !talkField.getText().equals("不能为空")) {
//获得 <SUF>
String msg = talkField.getText();
talkArea.append("我：" + msg + "\n");
talkField.setText("");
ip = tf_ip.getText();
NetTool.sendUDPBroadCast(ip, "enemy" + "," + msg);
} else {
talkField.setText("不能为空");
}
}
//退出游戏，加载主菜单
else if (e.getSource() == exitGame) {
dispose();
new SelectModel();
}
}
@Override
public void mouseClicked(MouseEvent e) {
if (e.getSource() == tf_ip) {
tf_ip.setText("");
} else if (e.getSource() == talkField) {
talkField.setText("");
}
}
}
| true |
31616_0 | package Leetcode.Java_code;
import java.util.HashMap;
/***************************************************
* @question
* 罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
*
* 字符 数值
* I 1
* V 5
* X 10
* L 50
* C 100
* D 500
* M 1000
* 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
*
* 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
*
* I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
* X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
* C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
* 给你一个整数，将其转为罗马数字。
*
* @tips
* 1 <= num <= 3999
*/
public class RomantoInt {
HashMap<Character, Integer> table = new HashMap<Character, Integer>(){{
put('I', 1);
put('V', 5);
put('X', 10);
put('L', 50);
put('C', 100);
put('D', 500);
put('M', 1000);
}};
public int convert(String s){
int result = 0;
for(int i = 0; i < s.length(); i++){
if(i < s.length() - 1 && table.get(s.charAt(i)) < table.get(s.charAt(i + 1)) )
result -= table.get(s.charAt(i));
else result += table.get(s.charAt(i));
}
return result;
}
public static void main(String[] args){
quickprint.print(new RomantoInt().convert("MCMXCIV"));
}
}
| MVPYPC/Leetcode | Java_code/RomantoInt.java | 623 | /***************************************************
* @question
* 罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
*
* 字符 数值
* I 1
* V 5
* X 10
* L 50
* C 100
* D 500
* M 1000
* 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
*
* 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
*
* I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
* X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
* C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
* 给你一个整数，将其转为罗马数字。
*
* @tips
* 1 <= num <= 3999
*/ | block_comment | zh-cn | package Leetcode.Java_code;
import java.util.HashMap;
/***************************************************
* @qu <SUF>*/
public class RomantoInt {
HashMap<Character, Integer> table = new HashMap<Character, Integer>(){{
put('I', 1);
put('V', 5);
put('X', 10);
put('L', 50);
put('C', 100);
put('D', 500);
put('M', 1000);
}};
public int convert(String s){
int result = 0;
for(int i = 0; i < s.length(); i++){
if(i < s.length() - 1 && table.get(s.charAt(i)) < table.get(s.charAt(i + 1)) )
result -= table.get(s.charAt(i));
else result += table.get(s.charAt(i));
}
return result;
}
public static void main(String[] args){
quickprint.print(new RomantoInt().convert("MCMXCIV"));
}
}
| false |
21615_2 | package task;
/**
* 定时任务.
*
* @author mxh.
* @version 2023/3/1 16:23
*/
public class DelayTask extends Thread {
/**
* 延迟时间.
*/
private long delayTime;
/**
* 任务.
*/
private Runnable runnable;
public DelayTask(long millis, Runnable runnable) {
this.delayTime = millis;
this.runnable = runnable;
}
@Override
public void run() {
try {
Thread.sleep(delayTime);
runnable.run();
} catch (InterruptedException ignore) {
}
}
}
| MXHDOIT/simple-java | src/task/DelayTask.java | 152 | /**
* 任务.
*/ | block_comment | zh-cn | package task;
/**
* 定时任务.
*
* @author mxh.
* @version 2023/3/1 16:23
*/
public class DelayTask extends Thread {
/**
* 延迟时间.
*/
private long delayTime;
/**
* 任务. <SUF>*/
private Runnable runnable;
public DelayTask(long millis, Runnable runnable) {
this.delayTime = millis;
this.runnable = runnable;
}
@Override
public void run() {
try {
Thread.sleep(delayTime);
runnable.run();
} catch (InterruptedException ignore) {
}
}
}
| false |
45493_7 | package com.myxh.chatgpt.domain.qa;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
/**
* @author MYXH
* @date 2023/12/11
* @description 文本问答，请求信息：OpenAI官网API构建参数；https://platform.openai.com/playground
* @GitHub <a href="https://github.com/MYXHcode">MYXHcode</a>
*/
@Data
@Builder
@Slf4j
@JsonInclude(JsonInclude.Include.NON_NULL)
@NoArgsConstructor
@AllArgsConstructor
public class QACompletionRequest implements Serializable
{
/**
* 默认模型
*/
@NonNull
@Builder.Default
private String model = Model.TEXT_DAVINCI_003.getCode();
/**
* 问题描述
*/
@NonNull
private String prompt;
private String suffix;
/**
* 控制温度【随机性】；0 到 2 之间。较高的值(如 0.8)将使输出更加随机，而较低的值(如 0.2)将使输出更加集中和确定
*/
private double temperature = 0.2;
/**
* 多样性控制；使用温度采样的替代方法称为核心采样，其中模型考虑具有 top_p 概率质量的令牌的结果。因此，0.1 意味着只考虑包含前 10% 概率质量的代币
*/
@JsonProperty("top_p")
private Double topP = 1d;
/**
* 为每个提示生成的完成次数
*/
private Integer n = 1;
/**
* 是否为流式输出；就是一蹦一蹦的，出来结果
*/
private boolean stream = false;
/**
* 停止输出标识
*/
private List<String> stop;
/**
* 输出字符串限制；0 ~ 4096
*/
@JsonProperty("max_tokens")
private Integer maxTokens = 2048;
@Builder.Default
private boolean echo = false;
/**
* 频率惩罚；降低模型重复同一行的可能性
*/
@JsonProperty("frequency_penalty")
private double frequencyPenalty = 0;
/**
* 存在惩罚；增强模型谈论新话题的可能性
*/
@JsonProperty("presence_penalty")
private double presencePenalty = 0;
/**
* 生成多个调用结果，只显示最佳的。这样会更多的消耗你的 api token
*/
@JsonProperty("best_of")
@Builder.Default
private Integer bestOf = 1;
private Integer logprobs;
@JsonProperty("logit_bias")
private Map logitBias;
/**
* 调用标识，避免重复调用
*/
private String user;
@Getter
@AllArgsConstructor
public enum Model
{
TEXT_DAVINCI_003("text-davinci-003"),
TEXT_DAVINCI_002("text-davinci-002"),
DAVINCI("davinci"),
;
private String code;
}
}
| MYXHcode/ChatGPT | chatgpt-sdk-java/src/main/java/com/myxh/chatgpt/domain/qa/QACompletionRequest.java | 794 | /**
* 停止输出标识
*/ | block_comment | zh-cn | package com.myxh.chatgpt.domain.qa;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
/**
* @author MYXH
* @date 2023/12/11
* @description 文本问答，请求信息：OpenAI官网API构建参数；https://platform.openai.com/playground
* @GitHub <a href="https://github.com/MYXHcode">MYXHcode</a>
*/
@Data
@Builder
@Slf4j
@JsonInclude(JsonInclude.Include.NON_NULL)
@NoArgsConstructor
@AllArgsConstructor
public class QACompletionRequest implements Serializable
{
/**
* 默认模型
*/
@NonNull
@Builder.Default
private String model = Model.TEXT_DAVINCI_003.getCode();
/**
* 问题描述
*/
@NonNull
private String prompt;
private String suffix;
/**
* 控制温度【随机性】；0 到 2 之间。较高的值(如 0.8)将使输出更加随机，而较低的值(如 0.2)将使输出更加集中和确定
*/
private double temperature = 0.2;
/**
* 多样性控制；使用温度采样的替代方法称为核心采样，其中模型考虑具有 top_p 概率质量的令牌的结果。因此，0.1 意味着只考虑包含前 10% 概率质量的代币
*/
@JsonProperty("top_p")
private Double topP = 1d;
/**
* 为每个提示生成的完成次数
*/
private Integer n = 1;
/**
* 是否为流式输出；就是一蹦一蹦的，出来结果
*/
private boolean stream = false;
/**
* 停止输 <SUF>*/
private List<String> stop;
/**
* 输出字符串限制；0 ~ 4096
*/
@JsonProperty("max_tokens")
private Integer maxTokens = 2048;
@Builder.Default
private boolean echo = false;
/**
* 频率惩罚；降低模型重复同一行的可能性
*/
@JsonProperty("frequency_penalty")
private double frequencyPenalty = 0;
/**
* 存在惩罚；增强模型谈论新话题的可能性
*/
@JsonProperty("presence_penalty")
private double presencePenalty = 0;
/**
* 生成多个调用结果，只显示最佳的。这样会更多的消耗你的 api token
*/
@JsonProperty("best_of")
@Builder.Default
private Integer bestOf = 1;
private Integer logprobs;
@JsonProperty("logit_bias")
private Map logitBias;
/**
* 调用标识，避免重复调用
*/
private String user;
@Getter
@AllArgsConstructor
public enum Model
{
TEXT_DAVINCI_003("text-davinci-003"),
TEXT_DAVINCI_002("text-davinci-002"),
DAVINCI("davinci"),
;
private String code;
}
}
| false |
22426_48 | package cretin;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import cretin.listener.JTextFieldHintListener;
import cretin.model.TranslateModel;
import net.sourceforge.pinyin4j.PinyinHelper;
import translate.TransApi;
public class Modify extends JFrame {
private final int mWidth = 750;
private final int mHeight = 490;
private static final String APP_ID = "20181010000217324";
private static final String SECURITY_KEY = "DmBJdQAnrfIEwgAfFKgN";
private JPanel panel;
private JButton buttonSelect;
private JButton buttonOk;
private JCheckBox jCheckBox0;
private JCheckBox jCheckBox;
private JCheckBox jCheckBox1;
private JCheckBox jCheckBox2;
private JCheckBox jCheckBox3;
private JTextField textField;
private JTextField textField1;
private JTextArea textArea;
private JComboBox jcb;
private JLabel jLabel;
private JScrollPane jsp;
private String currPathString;
private List<File> list = new ArrayList<File>();
private String separator;
private Gson gson;
private TransApi api;
private String jcbList[] = { "不限", "5", "8", "11", "14", "17" };
public Modify() {
gson = new Gson();
setTitle("文件批量修改器");
setSize(mWidth, mHeight);
setLocationRelativeTo(null);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel = new JPanel();
buttonSelect = new JButton("选择文件");
buttonOk = new JButton("开始");
jCheckBox0 = new JCheckBox("保留原文件名");
jCheckBox = new JCheckBox("文件名中文转拼音");
jCheckBox1 = new JCheckBox("文件名中文转英文");
jCheckBox2 = new JCheckBox("仅翻译文件名");
jCheckBox3 = new JCheckBox("按规则替换");
jLabel = new JLabel("设置文件名称最大长度值");
jcb = new JComboBox(jcbList);
jCheckBox1.setSelected(true);
textField = new JTextField(15);
textField1 = new JTextField(15);
textField1.setEditable(false);
textField.setText("@2x @3x");
textField1.setText("A a;- _;");
textField.addFocusListener(new JTextFieldHintListener("请输入尺寸后缀", textField));
textField1.addFocusListener(new JTextFieldHintListener("请输入匹配规则", textField1));
textArea = new JTextArea(24, 60);
jsp = new JScrollPane(textArea);
jsp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
textArea.setLineWrap(true);// 设置文本区的换行策略
textArea.setEditable(false);
separator = System.getProperties().getProperty("file.separator");
panel.add(textField);
panel.add(jCheckBox0);
panel.add(jCheckBox);
panel.add(jCheckBox1);
panel.add(jCheckBox2);
panel.add(textField1);
panel.add(jCheckBox3);
panel.add(jLabel);
panel.add(jcb);
panel.add(buttonSelect);
panel.add(buttonOk);
panel.add(jsp);
// 讲述使用说明
textArea.append(
"欢迎使用Cretin文件批量修改器 \n1、先在文本框输入不同尺寸图片的后缀(比如：pic@2x.png(两倍图),pic@3x.png(三倍图),那么您应该输入@2x跟@3x)，中间以空格隔开\n");
textArea.append("2、选择包含所有图片文件的文件夹\n");
textArea.append("3、点击开始，将为你自动分类图片\n");
textArea.append("4、图片分类成功后会在你选择的文件夹下面新建以后缀命名的文件夹(比如：@2x和@3两个文件夹，分别装有两倍图和三倍图图片)\n"
+ "5、文件名中文转拼音：自动将汉字转化成拼音作为文件名\n" + "7、文件名中文转英文：自动将汉字转化成英文作为文件名\n"
+ "8、仅翻译文件名：不会按后缀名进行分类，仅仅翻译文件夹内文件的名称\n" + "9、按规则替换：不同的规则用;分隔开，每一组规则通过空格分割，比如- _（其中A a特指英文字母大写转小写，Android资源文件不能有大写），程序会用空格后面字符替换掉前面的内容\n"
+ "10、设置文件名称最大长度值：设置后当文件名超过此长度后会自动截取\n" + "11、使用中有什么问题可联系：mxnzp_life@163.com\n");
textArea.append("-----------------------------------------\n");
add(panel);
jCheckBox.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
jCheckBox0.setSelected(false);
jCheckBox1.setSelected(false);
}
}
});
jCheckBox0.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
jCheckBox.setSelected(false);
jCheckBox1.setSelected(false);
}
}
});
jCheckBox1.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
jCheckBox0.setSelected(false);
jCheckBox.setSelected(false);
}
}
});
jCheckBox3.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
textField1.setEditable(true);
} else {
textField1.setEditable(false);
}
}
});
// 选择文件夹
buttonSelect.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (jCheckBox2.isSelected()) {
// 仅翻译文件名
textArea.append("当前模式:仅修改文件名" + "\n");
} else {
String tag = textField.getText();
if (tag == null || tag.equals("")) {
JOptionPane.showMessageDialog(getContentPane(), "请在文本框中输入后缀", "系统信息",
JOptionPane.WARNING_MESSAGE);
return;
}
textArea.append("当前模式:根据后缀区分并命名\n输入的后缀为:" + textField.getText() + "\n");
}
JFileChooser jfc = new JFileChooser();
jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
jfc.showDialog(new JLabel(), "选择文件夹");
File file = jfc.getSelectedFile();
if (file != null) {
textArea.append("已选择文件夹：" + file.getAbsolutePath() + "\n");
currPathString = file.getAbsolutePath();
} else {
textArea.append("取消选择文件夹......\n");
}
}
});
// 开始
buttonOk.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (jCheckBox2.isSelected()) {
// 仅翻译文件名
} else {
String tag = textField.getText();
if (tag == null || tag.equals("")) {
JOptionPane.showMessageDialog(getContentPane(), "请在文本框中输入后缀", "系统信息",
JOptionPane.WARNING_MESSAGE);
return;
}
}
if (currPathString == null || currPathString.equals("")) {
JOptionPane.showMessageDialog(getContentPane(), "请选择文件夹", "系统信息", JOptionPane.WARNING_MESSAGE);
return;
}
if (!jCheckBox.isSelected() && !jCheckBox0.isSelected() && !jCheckBox1.isSelected()) {
JOptionPane.showMessageDialog(getContentPane(), "请选择处理文件名的模式", "系统信息", JOptionPane.WARNING_MESSAGE);
return;
}
doIt();
}
});
setVisible(true);
api = new TransApi(APP_ID, SECURITY_KEY);
}
private List<String> fileNameList = new ArrayList<String>();
private int count = 0;
/**
* 思路 1、遍历所有的文件 2、找出所有以@2和@3结尾的文件 3、将以不同后缀结尾的文件分别复制到各自的文件夹下 4、去掉后缀 5、搞定
*/
private void doIt() {
textArea.append("开始遍历文件....................\n");
// 所有的文件列表
list.clear();
// 清除所有缓存
keys.clear();
try {
showAllFiles(new File(currPathString));
} catch (Exception e) {
e.printStackTrace();
}
count = 0;
final String[] str = textField.getText().split(" ");
if (jCheckBox2.isSelected()) {
count = 1;
} else {
count = textField.getText().split(" ").length;
}
final List<ArrayList<String>> sourceArrayLists = new ArrayList<ArrayList<String>>();
for (int i = 0; i < count; i++) {
sourceArrayLists.add(new ArrayList<String>());
}
System.out.println("sourceArrayLists.size() " + sourceArrayLists.size());
System.out.println("list.size() " + list.size());
for (int i = 0; i < list.size(); i++) {
if (jCheckBox2.isSelected()) {
// 仅修改文件
String pathString = list.get(i).getAbsolutePath();
sourceArrayLists.get(0).add(pathString);
System.out.println("翻译" + " " + pathString);
} else {
HH: for (int j = 0; j < count; j++) {
String pathString = list.get(i).getAbsolutePath();
if (pathString.contains(str[j])) {
sourceArrayLists.get(j).add(pathString);
System.out.println(str[j] + " " + pathString);
break HH;
}
}
}
}
textArea.append("开始复制文件....................\n");
new Thread(new Runnable() {
public void run() {
int length = 100000;
try {
length = Integer.parseInt(jcb.getSelectedItem().toString());
} catch (Exception e) {
// TODO: handle exception
}
for (int i = 0; i < count; i++) {
textArea.append("第" + (i + 1) + "轮复制....................\n");
fileNameList.clear();
for (int j = 0; j < sourceArrayLists.get(i).size(); j++) {
String path = sourceArrayLists.get(i).get(j);
// banner.png
String pathAim = path.substring(path.lastIndexOf(separator) + 1).replaceAll(str[i], "");
if (jCheckBox0.isSelected()) {
// 保留原文件名
String end = pathAim.substring(pathAim.lastIndexOf(".") + 1);
String start = pathAim.substring(0, pathAim.lastIndexOf("."));
System.out.println(pathAim + "->" + start);
String result;
if (length < start.length()) {
// 长度超了
start = start.substring(0, length);
}
result = start + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = start.substring(0, start.length() - (index + "").length()) + index++ + "."
+ end;
}
System.out.println(path);
System.out.println(result);
// C:\Users\sks\Desktop\resources\resources\banner@2x.png
// C:\Users\sks\Desktop\resources\resources/@2x
if (jCheckBox2.isSelected()) {
// 仅翻译
copyFile(path, currPathString + separator + "翻译文件名", result);
} else
copyFile(path, currPathString + separator + str[i], result);
} else if (jCheckBox.isSelected()) {
// 中文转拼音
String end = pathAim.substring(pathAim.lastIndexOf(".") + 1);
String start = pathAim.substring(0, pathAim.lastIndexOf("."));
String resultStart = getPinyi(start);
System.out.println(pathAim + "->" + resultStart);
String result;
if (resultStart == null || resultStart.equals("")) {
// 不含中文 原文输出
if (length < start.length()) {
// 长度超了
start = start.substring(0, length);
}
result = start + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = start.substring(0, start.length() - (index + "").length()) + index++ + "."
+ end;
}
} else {
if (length < resultStart.length()) {
// 长度超了
resultStart = resultStart.substring(0, length);
}
result = resultStart + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = resultStart.substring(0, resultStart.length() - (index + "").length())
+ index++ + "." + end;
}
}
fileNameList.add(result);
System.out.println(path);
System.out.println(result);
// C:\Users\sks\Desktop\resources\resources\banner@2x.png
// C:\Users\sks\Desktop\resources\resources/@2x
if (jCheckBox2.isSelected()) {
// 仅翻译
copyFile(path, currPathString + separator + "翻译文件名", result);
} else
copyFile(path, currPathString + separator + str[i], result);
} else if (jCheckBox1.isSelected()) {
// 用英文翻译
String end = pathAim.substring(pathAim.lastIndexOf(".") + 1);
String start = pathAim.substring(0, pathAim.lastIndexOf("."));
// banner.png banner
if (keys.containsKey(start)) {
start = keys.get(start);
} else
start = dealTranslate(start);
System.out.println(pathAim + "->" + start);
String result;
if (length < start.length()) {
// 长度超了
start = start.substring(0, length);
}
result = start + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = start.substring(0, start.length() - (index + "").length()) + index++ + "."
+ end;
}
fileNameList.add(result);
System.out.println(path);
System.out.println(result);
// C:\Users\sks\Desktop\resources\resources\banner@2x.png
// C:\Users\sks\Desktop\resources\resources/@2x
if (jCheckBox2.isSelected()) {
// 仅翻译
copyFile(path, currPathString + separator + "翻译文件名", result);
} else
copyFile(path, currPathString + separator + str[i], result);
}
}
}
textArea.append("********************\n");
textArea.append("哈哈，文件批量修改完成\n");
textArea.append("********************\n");
}
}).start();
}
/**
* 复制单个文件
*
* @param oldPath
* String 原文件路径 如：c:/fqf.txt
* @param newPath
* String 复制后路径 如：f:/fqf.txt
* @return boolean
*/
public synchronized void copyFile(String oldPath, String newPath, String fileName) {
fileName = fileName.replaceAll(" ", "");
if (jCheckBox3.isSelected()) {
// 按规则替换文件名 - _;
String text = textField1.getText();
if (text != null && !text.equals("")) {
String[] split = text.split(";");
for (int i = 0; i < split.length; i++) {
String aim = split[i];
if (aim.contains(" ") && aim.split(" ").length == 2) {
if("A".equals(aim.split(" ")[0])&&"a".equals(aim.split(" ")[1])) {
//大写转小写
fileName = fileName.toLowerCase();
}else {
fileName = fileName.replaceAll(aim.split(" ")[0], aim.split(" ")[1]);
}
}
}
}
}
InputStream inStream = null;
FileOutputStream fs = null;
try {
int byteread = 0;
File oldfile = new File(oldPath);
File newFile = new File(newPath);
if (!newFile.exists()) {
newFile.mkdir();
}
File tempFile = new File(newFile.getAbsoluteFile(), fileName);
if (oldfile.exists()) { // 文件存在时
inStream = new FileInputStream(oldPath); // 读入原文件
fs = new FileOutputStream(tempFile.getAbsoluteFile());
byte[] buffer = new byte[1444];
while ((byteread = inStream.read(buffer)) != -1) {
fs.write(buffer, 0, byteread);
}
textArea.append(oldPath + "->" + fileName + " 复制成功\n");
inStream.close();
fs.close();
}
} catch (Exception e) {
System.out.println("复制单个文件操作出错");
e.printStackTrace();
} finally {
try {
if (inStream != null)
inStream.close();
if (fs != null)
fs.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String getNewPath(String oldPath, String split) {
String fileName = oldPath.substring(oldPath.lastIndexOf(separator));
return currPathString + File.separator + split + fileName.replaceAll(split, "");
}
private void showAllFiles(File dir) throws Exception {
File[] fs = dir.listFiles();
if (fs == null) {
JOptionPane.showMessageDialog(getContentPane(), "文件夹内无数据\n" + dir.getPath(), "系统信息",
JOptionPane.WARNING_MESSAGE);
return;
}
for (int i = 0; i < fs.length; i++) {
if (fs[i].isDirectory()) {
textArea.append("文件夹:" + fs[i].getAbsolutePath() + "\n");
try {
showAllFiles(fs[i]);
} catch (Exception e) {
}
} else {
textArea.append("文件:" + fs[i].getAbsolutePath() + "\n");
list.add(fs[i]);
}
}
}
// 程序入口
public static void main(String[] args) {
new Modify();
}
// 中文验证规则
private String regEx = "[\u4e00-\u9fa5]{1,}";
// 编译正则表达式
private Pattern pattern = Pattern.compile(regEx);
private Map<String, String> keys = new HashMap<String, String>();
/**
* 对翻译结果进行处理
*
* @param res
* @return
*/
public String dealTranslate(String res) {
Matcher matcher = pattern.matcher(res);
// 字符串是否与正则表达式相匹配
StringBuffer finalStr = new StringBuffer();
int end = 0;
while (matcher.find()) {
finalStr.append(res.substring(end, matcher.start()));
String result = translate(matcher.group());
finalStr.append(result);
end = matcher.end();
}
finalStr.append(res.substring(end, res.length()));
String result = finalStr.toString().replaceAll(" ", "_");
keys.put(res, result);
return result;
}
/**
* 翻译
*
* @param res
* @return
*/
private String translate(String res) {
String result = api.getTransResult(res, "zh", "en");
TranslateModel translateModel = gson.fromJson(result, new TypeToken<TranslateModel>() {
}.getType());
if (translateModel.getTrans_result() != null && !translateModel.getTrans_result().isEmpty()) {
String translate = translateModel.getTrans_result().get(0).getDst().toLowerCase();
return translate;
}
return "";
}
/**
* 获取文字的拼音组合
*
* @param text
* @return
*/
public static String getPinyi(String text) {
// if (text.length() > 4) {
// text = text.substring(0, 4);
// }
text = text.replaceAll(" ", "");
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < text.length(); i++) {
String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(text.charAt(i));
if (pinyinArray != null && pinyinArray.length > 0) {
String str = pinyinArray[0];
stringBuffer.append(str.substring(0, str.length() - 1));
}
}
return stringBuffer.toString();
}
}
| MZCretin/FileBatchModification | src/cretin/Modify.java | 5,846 | // 编译正则表达式 | line_comment | zh-cn | package cretin;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import cretin.listener.JTextFieldHintListener;
import cretin.model.TranslateModel;
import net.sourceforge.pinyin4j.PinyinHelper;
import translate.TransApi;
public class Modify extends JFrame {
private final int mWidth = 750;
private final int mHeight = 490;
private static final String APP_ID = "20181010000217324";
private static final String SECURITY_KEY = "DmBJdQAnrfIEwgAfFKgN";
private JPanel panel;
private JButton buttonSelect;
private JButton buttonOk;
private JCheckBox jCheckBox0;
private JCheckBox jCheckBox;
private JCheckBox jCheckBox1;
private JCheckBox jCheckBox2;
private JCheckBox jCheckBox3;
private JTextField textField;
private JTextField textField1;
private JTextArea textArea;
private JComboBox jcb;
private JLabel jLabel;
private JScrollPane jsp;
private String currPathString;
private List<File> list = new ArrayList<File>();
private String separator;
private Gson gson;
private TransApi api;
private String jcbList[] = { "不限", "5", "8", "11", "14", "17" };
public Modify() {
gson = new Gson();
setTitle("文件批量修改器");
setSize(mWidth, mHeight);
setLocationRelativeTo(null);
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
panel = new JPanel();
buttonSelect = new JButton("选择文件");
buttonOk = new JButton("开始");
jCheckBox0 = new JCheckBox("保留原文件名");
jCheckBox = new JCheckBox("文件名中文转拼音");
jCheckBox1 = new JCheckBox("文件名中文转英文");
jCheckBox2 = new JCheckBox("仅翻译文件名");
jCheckBox3 = new JCheckBox("按规则替换");
jLabel = new JLabel("设置文件名称最大长度值");
jcb = new JComboBox(jcbList);
jCheckBox1.setSelected(true);
textField = new JTextField(15);
textField1 = new JTextField(15);
textField1.setEditable(false);
textField.setText("@2x @3x");
textField1.setText("A a;- _;");
textField.addFocusListener(new JTextFieldHintListener("请输入尺寸后缀", textField));
textField1.addFocusListener(new JTextFieldHintListener("请输入匹配规则", textField1));
textArea = new JTextArea(24, 60);
jsp = new JScrollPane(textArea);
jsp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
textArea.setLineWrap(true);// 设置文本区的换行策略
textArea.setEditable(false);
separator = System.getProperties().getProperty("file.separator");
panel.add(textField);
panel.add(jCheckBox0);
panel.add(jCheckBox);
panel.add(jCheckBox1);
panel.add(jCheckBox2);
panel.add(textField1);
panel.add(jCheckBox3);
panel.add(jLabel);
panel.add(jcb);
panel.add(buttonSelect);
panel.add(buttonOk);
panel.add(jsp);
// 讲述使用说明
textArea.append(
"欢迎使用Cretin文件批量修改器 \n1、先在文本框输入不同尺寸图片的后缀(比如：pic@2x.png(两倍图),pic@3x.png(三倍图),那么您应该输入@2x跟@3x)，中间以空格隔开\n");
textArea.append("2、选择包含所有图片文件的文件夹\n");
textArea.append("3、点击开始，将为你自动分类图片\n");
textArea.append("4、图片分类成功后会在你选择的文件夹下面新建以后缀命名的文件夹(比如：@2x和@3两个文件夹，分别装有两倍图和三倍图图片)\n"
+ "5、文件名中文转拼音：自动将汉字转化成拼音作为文件名\n" + "7、文件名中文转英文：自动将汉字转化成英文作为文件名\n"
+ "8、仅翻译文件名：不会按后缀名进行分类，仅仅翻译文件夹内文件的名称\n" + "9、按规则替换：不同的规则用;分隔开，每一组规则通过空格分割，比如- _（其中A a特指英文字母大写转小写，Android资源文件不能有大写），程序会用空格后面字符替换掉前面的内容\n"
+ "10、设置文件名称最大长度值：设置后当文件名超过此长度后会自动截取\n" + "11、使用中有什么问题可联系：mxnzp_life@163.com\n");
textArea.append("-----------------------------------------\n");
add(panel);
jCheckBox.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
jCheckBox0.setSelected(false);
jCheckBox1.setSelected(false);
}
}
});
jCheckBox0.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
jCheckBox.setSelected(false);
jCheckBox1.setSelected(false);
}
}
});
jCheckBox1.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
jCheckBox0.setSelected(false);
jCheckBox.setSelected(false);
}
}
});
jCheckBox3.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {
JCheckBox jcb = (JCheckBox) e.getItem();// 将得到的事件强制转化为JCheckBox类
if (jcb.isSelected()) {// 判断是否被选择
textField1.setEditable(true);
} else {
textField1.setEditable(false);
}
}
});
// 选择文件夹
buttonSelect.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (jCheckBox2.isSelected()) {
// 仅翻译文件名
textArea.append("当前模式:仅修改文件名" + "\n");
} else {
String tag = textField.getText();
if (tag == null || tag.equals("")) {
JOptionPane.showMessageDialog(getContentPane(), "请在文本框中输入后缀", "系统信息",
JOptionPane.WARNING_MESSAGE);
return;
}
textArea.append("当前模式:根据后缀区分并命名\n输入的后缀为:" + textField.getText() + "\n");
}
JFileChooser jfc = new JFileChooser();
jfc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
jfc.showDialog(new JLabel(), "选择文件夹");
File file = jfc.getSelectedFile();
if (file != null) {
textArea.append("已选择文件夹：" + file.getAbsolutePath() + "\n");
currPathString = file.getAbsolutePath();
} else {
textArea.append("取消选择文件夹......\n");
}
}
});
// 开始
buttonOk.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (jCheckBox2.isSelected()) {
// 仅翻译文件名
} else {
String tag = textField.getText();
if (tag == null || tag.equals("")) {
JOptionPane.showMessageDialog(getContentPane(), "请在文本框中输入后缀", "系统信息",
JOptionPane.WARNING_MESSAGE);
return;
}
}
if (currPathString == null || currPathString.equals("")) {
JOptionPane.showMessageDialog(getContentPane(), "请选择文件夹", "系统信息", JOptionPane.WARNING_MESSAGE);
return;
}
if (!jCheckBox.isSelected() && !jCheckBox0.isSelected() && !jCheckBox1.isSelected()) {
JOptionPane.showMessageDialog(getContentPane(), "请选择处理文件名的模式", "系统信息", JOptionPane.WARNING_MESSAGE);
return;
}
doIt();
}
});
setVisible(true);
api = new TransApi(APP_ID, SECURITY_KEY);
}
private List<String> fileNameList = new ArrayList<String>();
private int count = 0;
/**
* 思路 1、遍历所有的文件 2、找出所有以@2和@3结尾的文件 3、将以不同后缀结尾的文件分别复制到各自的文件夹下 4、去掉后缀 5、搞定
*/
private void doIt() {
textArea.append("开始遍历文件....................\n");
// 所有的文件列表
list.clear();
// 清除所有缓存
keys.clear();
try {
showAllFiles(new File(currPathString));
} catch (Exception e) {
e.printStackTrace();
}
count = 0;
final String[] str = textField.getText().split(" ");
if (jCheckBox2.isSelected()) {
count = 1;
} else {
count = textField.getText().split(" ").length;
}
final List<ArrayList<String>> sourceArrayLists = new ArrayList<ArrayList<String>>();
for (int i = 0; i < count; i++) {
sourceArrayLists.add(new ArrayList<String>());
}
System.out.println("sourceArrayLists.size() " + sourceArrayLists.size());
System.out.println("list.size() " + list.size());
for (int i = 0; i < list.size(); i++) {
if (jCheckBox2.isSelected()) {
// 仅修改文件
String pathString = list.get(i).getAbsolutePath();
sourceArrayLists.get(0).add(pathString);
System.out.println("翻译" + " " + pathString);
} else {
HH: for (int j = 0; j < count; j++) {
String pathString = list.get(i).getAbsolutePath();
if (pathString.contains(str[j])) {
sourceArrayLists.get(j).add(pathString);
System.out.println(str[j] + " " + pathString);
break HH;
}
}
}
}
textArea.append("开始复制文件....................\n");
new Thread(new Runnable() {
public void run() {
int length = 100000;
try {
length = Integer.parseInt(jcb.getSelectedItem().toString());
} catch (Exception e) {
// TODO: handle exception
}
for (int i = 0; i < count; i++) {
textArea.append("第" + (i + 1) + "轮复制....................\n");
fileNameList.clear();
for (int j = 0; j < sourceArrayLists.get(i).size(); j++) {
String path = sourceArrayLists.get(i).get(j);
// banner.png
String pathAim = path.substring(path.lastIndexOf(separator) + 1).replaceAll(str[i], "");
if (jCheckBox0.isSelected()) {
// 保留原文件名
String end = pathAim.substring(pathAim.lastIndexOf(".") + 1);
String start = pathAim.substring(0, pathAim.lastIndexOf("."));
System.out.println(pathAim + "->" + start);
String result;
if (length < start.length()) {
// 长度超了
start = start.substring(0, length);
}
result = start + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = start.substring(0, start.length() - (index + "").length()) + index++ + "."
+ end;
}
System.out.println(path);
System.out.println(result);
// C:\Users\sks\Desktop\resources\resources\banner@2x.png
// C:\Users\sks\Desktop\resources\resources/@2x
if (jCheckBox2.isSelected()) {
// 仅翻译
copyFile(path, currPathString + separator + "翻译文件名", result);
} else
copyFile(path, currPathString + separator + str[i], result);
} else if (jCheckBox.isSelected()) {
// 中文转拼音
String end = pathAim.substring(pathAim.lastIndexOf(".") + 1);
String start = pathAim.substring(0, pathAim.lastIndexOf("."));
String resultStart = getPinyi(start);
System.out.println(pathAim + "->" + resultStart);
String result;
if (resultStart == null || resultStart.equals("")) {
// 不含中文 原文输出
if (length < start.length()) {
// 长度超了
start = start.substring(0, length);
}
result = start + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = start.substring(0, start.length() - (index + "").length()) + index++ + "."
+ end;
}
} else {
if (length < resultStart.length()) {
// 长度超了
resultStart = resultStart.substring(0, length);
}
result = resultStart + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = resultStart.substring(0, resultStart.length() - (index + "").length())
+ index++ + "." + end;
}
}
fileNameList.add(result);
System.out.println(path);
System.out.println(result);
// C:\Users\sks\Desktop\resources\resources\banner@2x.png
// C:\Users\sks\Desktop\resources\resources/@2x
if (jCheckBox2.isSelected()) {
// 仅翻译
copyFile(path, currPathString + separator + "翻译文件名", result);
} else
copyFile(path, currPathString + separator + str[i], result);
} else if (jCheckBox1.isSelected()) {
// 用英文翻译
String end = pathAim.substring(pathAim.lastIndexOf(".") + 1);
String start = pathAim.substring(0, pathAim.lastIndexOf("."));
// banner.png banner
if (keys.containsKey(start)) {
start = keys.get(start);
} else
start = dealTranslate(start);
System.out.println(pathAim + "->" + start);
String result;
if (length < start.length()) {
// 长度超了
start = start.substring(0, length);
}
result = start + "." + end;
int index = 0;
while (fileNameList.contains(result)) {
// 此次不合格
result = start.substring(0, start.length() - (index + "").length()) + index++ + "."
+ end;
}
fileNameList.add(result);
System.out.println(path);
System.out.println(result);
// C:\Users\sks\Desktop\resources\resources\banner@2x.png
// C:\Users\sks\Desktop\resources\resources/@2x
if (jCheckBox2.isSelected()) {
// 仅翻译
copyFile(path, currPathString + separator + "翻译文件名", result);
} else
copyFile(path, currPathString + separator + str[i], result);
}
}
}
textArea.append("********************\n");
textArea.append("哈哈，文件批量修改完成\n");
textArea.append("********************\n");
}
}).start();
}
/**
* 复制单个文件
*
* @param oldPath
* String 原文件路径 如：c:/fqf.txt
* @param newPath
* String 复制后路径 如：f:/fqf.txt
* @return boolean
*/
public synchronized void copyFile(String oldPath, String newPath, String fileName) {
fileName = fileName.replaceAll(" ", "");
if (jCheckBox3.isSelected()) {
// 按规则替换文件名 - _;
String text = textField1.getText();
if (text != null && !text.equals("")) {
String[] split = text.split(";");
for (int i = 0; i < split.length; i++) {
String aim = split[i];
if (aim.contains(" ") && aim.split(" ").length == 2) {
if("A".equals(aim.split(" ")[0])&&"a".equals(aim.split(" ")[1])) {
//大写转小写
fileName = fileName.toLowerCase();
}else {
fileName = fileName.replaceAll(aim.split(" ")[0], aim.split(" ")[1]);
}
}
}
}
}
InputStream inStream = null;
FileOutputStream fs = null;
try {
int byteread = 0;
File oldfile = new File(oldPath);
File newFile = new File(newPath);
if (!newFile.exists()) {
newFile.mkdir();
}
File tempFile = new File(newFile.getAbsoluteFile(), fileName);
if (oldfile.exists()) { // 文件存在时
inStream = new FileInputStream(oldPath); // 读入原文件
fs = new FileOutputStream(tempFile.getAbsoluteFile());
byte[] buffer = new byte[1444];
while ((byteread = inStream.read(buffer)) != -1) {
fs.write(buffer, 0, byteread);
}
textArea.append(oldPath + "->" + fileName + " 复制成功\n");
inStream.close();
fs.close();
}
} catch (Exception e) {
System.out.println("复制单个文件操作出错");
e.printStackTrace();
} finally {
try {
if (inStream != null)
inStream.close();
if (fs != null)
fs.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String getNewPath(String oldPath, String split) {
String fileName = oldPath.substring(oldPath.lastIndexOf(separator));
return currPathString + File.separator + split + fileName.replaceAll(split, "");
}
private void showAllFiles(File dir) throws Exception {
File[] fs = dir.listFiles();
if (fs == null) {
JOptionPane.showMessageDialog(getContentPane(), "文件夹内无数据\n" + dir.getPath(), "系统信息",
JOptionPane.WARNING_MESSAGE);
return;
}
for (int i = 0; i < fs.length; i++) {
if (fs[i].isDirectory()) {
textArea.append("文件夹:" + fs[i].getAbsolutePath() + "\n");
try {
showAllFiles(fs[i]);
} catch (Exception e) {
}
} else {
textArea.append("文件:" + fs[i].getAbsolutePath() + "\n");
list.add(fs[i]);
}
}
}
// 程序入口
public static void main(String[] args) {
new Modify();
}
// 中文验证规则
private String regEx = "[\u4e00-\u9fa5]{1,}";
// 编译 <SUF>
private Pattern pattern = Pattern.compile(regEx);
private Map<String, String> keys = new HashMap<String, String>();
/**
* 对翻译结果进行处理
*
* @param res
* @return
*/
public String dealTranslate(String res) {
Matcher matcher = pattern.matcher(res);
// 字符串是否与正则表达式相匹配
StringBuffer finalStr = new StringBuffer();
int end = 0;
while (matcher.find()) {
finalStr.append(res.substring(end, matcher.start()));
String result = translate(matcher.group());
finalStr.append(result);
end = matcher.end();
}
finalStr.append(res.substring(end, res.length()));
String result = finalStr.toString().replaceAll(" ", "_");
keys.put(res, result);
return result;
}
/**
* 翻译
*
* @param res
* @return
*/
private String translate(String res) {
String result = api.getTransResult(res, "zh", "en");
TranslateModel translateModel = gson.fromJson(result, new TypeToken<TranslateModel>() {
}.getType());
if (translateModel.getTrans_result() != null && !translateModel.getTrans_result().isEmpty()) {
String translate = translateModel.getTrans_result().get(0).getDst().toLowerCase();
return translate;
}
return "";
}
/**
* 获取文字的拼音组合
*
* @param text
* @return
*/
public static String getPinyi(String text) {
// if (text.length() > 4) {
// text = text.substring(0, 4);
// }
text = text.replaceAll(" ", "");
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < text.length(); i++) {
String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(text.charAt(i));
if (pinyinArray != null && pinyinArray.length > 0) {
String str = pinyinArray[0];
stringBuffer.append(str.substring(0, str.length() - 1));
}
}
return stringBuffer.toString();
}
}
| true |
33611_43 | /*
* Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
*/
package com.baidu.ocr.ui.camera;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import com.baidu.idcardquality.IDcardQualityProcess;
import com.baidu.ocr.ui.R;
import com.baidu.ocr.ui.util.DimensionUtil;
import com.baidu.ocr.ui.util.ImageUtil;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapRegionDecoder;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.IntDef;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
/**
* 负责，相机的管理。同时提供，裁剪遮罩功能。
*/
public class CameraView extends FrameLayout {
private int maskType;
/**
* 照相回调
*/
interface OnTakePictureCallback {
void onPictureTaken(Bitmap bitmap);
}
/**
* 垂直方向 {@link #setOrientation(int)}
*/
public static final int ORIENTATION_PORTRAIT = 0;
/**
* 水平方向 {@link #setOrientation(int)}
*/
public static final int ORIENTATION_HORIZONTAL = 90;
/**
* 水平翻转方向 {@link #setOrientation(int)}
*/
public static final int ORIENTATION_INVERT = 270;
/**
* 本地模型授权，加载成功
*/
public static final int NATIVE_AUTH_INIT_SUCCESS = 0;
/**
* 本地模型授权，缺少SO
*/
public static final int NATIVE_SOLOAD_FAIL = 10;
/**
* 本地模型授权，授权失败，token异常
*/
public static final int NATIVE_AUTH_FAIL = 11;
/**
* 本地模型授权，模型加载失败
*/
public static final int NATIVE_INIT_FAIL = 12;
/**
* 是否已经通过本地质量控制扫描
*/
private final int SCAN_SUCCESS = 0;
public void setInitNativeStatus(int initNativeStatus) {
this.initNativeStatus = initNativeStatus;
}
/**
* 本地检测初始化，模型加载标识
*/
private int initNativeStatus = NATIVE_AUTH_INIT_SUCCESS;
@IntDef({ORIENTATION_PORTRAIT, ORIENTATION_HORIZONTAL, ORIENTATION_INVERT})
public @interface Orientation {
}
private CameraViewTakePictureCallback cameraViewTakePictureCallback = new CameraViewTakePictureCallback();
private ICameraControl cameraControl;
/**
* 相机预览View
*/
private View displayView;
/**
* 身份证，银行卡，等裁剪用的遮罩
*/
private MaskView maskView;
/**
* 用于显示提示证 "请对齐身份证正面" 之类的背景
*/
private ImageView hintView;
/**
* 用于显示提示证 "请对齐身份证正面" 之类的文字
*/
private TextView hintViewText;
/**
* 提示文案容器
*/
private LinearLayout hintViewTextWrapper;
/**
* 是否是本地质量控制扫描
*/
private boolean isEnableScan;
public void setEnableScan(boolean enableScan) {
isEnableScan = enableScan;
}
/**
* UI线程的handler
*/
Handler uiHandler = new Handler(Looper.getMainLooper());
public ICameraControl getCameraControl() {
return cameraControl;
}
public void setOrientation(@Orientation int orientation) {
cameraControl.setDisplayOrientation(orientation);
}
public CameraView(Context context) {
super(context);
init();
}
public CameraView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public CameraView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
public void start() {
cameraControl.start();
setKeepScreenOn(true);
}
public void stop() {
cameraControl.stop();
setKeepScreenOn(false);
}
public void takePicture(final File file, final OnTakePictureCallback callback) {
cameraViewTakePictureCallback.file = file;
cameraViewTakePictureCallback.callback = callback;
cameraControl.takePicture(cameraViewTakePictureCallback);
}
private OnTakePictureCallback autoPictureCallback;
public void setAutoPictureCallback(OnTakePictureCallback callback) {
autoPictureCallback = callback;
}
public void setMaskType(@MaskView.MaskType int maskType, final Context ctx) {
maskView.setMaskType(maskType);
maskView.setVisibility(VISIBLE);
hintView.setVisibility(VISIBLE);
int hintResourceId = R.drawable.bd_ocr_hint_align_id_card;
this.maskType = maskType;
boolean isNeedSetImage = true;
switch (maskType) {
case MaskView.MASK_TYPE_ID_CARD_FRONT:
hintResourceId = R.drawable.bd_ocr_round_corner;
isNeedSetImage = false;
break;
case MaskView.MASK_TYPE_ID_CARD_BACK:
isNeedSetImage = false;
hintResourceId = R.drawable.bd_ocr_round_corner;
break;
case MaskView.MASK_TYPE_BANK_CARD:
hintResourceId = R.drawable.bd_ocr_hint_align_bank_card;
break;
case MaskView.MASK_TYPE_NONE:
default:
maskView.setVisibility(INVISIBLE);
hintView.setVisibility(INVISIBLE);
break;
}
if (isNeedSetImage) {
hintView.setImageResource(hintResourceId);
hintViewTextWrapper.setVisibility(INVISIBLE);
}
if (maskType == MaskView.MASK_TYPE_ID_CARD_FRONT && isEnableScan) {
cameraControl.setDetectCallback(new ICameraControl.OnDetectPictureCallback() {
@Override
public int onDetect(byte[] data, int rotation) {
return detect(data, rotation);
}
});
}
if (maskType == MaskView.MASK_TYPE_ID_CARD_BACK && isEnableScan) {
cameraControl.setDetectCallback(new ICameraControl.OnDetectPictureCallback() {
@Override
public int onDetect(byte[] data, int rotation) {
return detect(data, rotation);
}
});
}
}
private int detect(byte[] data, final int rotation) {
if (initNativeStatus != NATIVE_AUTH_INIT_SUCCESS) {
showTipMessage(initNativeStatus);
return 1;
}
// 扫描成功阻止多余的操作
if (cameraControl.getAbortingScan().get()) {
return 0;
}
Rect previewFrame = cameraControl.getPreviewFrame();
if (maskView.getWidth() == 0 || maskView.getHeight() == 0
|| previewFrame.width() == 0 || previewFrame.height() == 0) {
return 0;
}
// BitmapRegionDecoder不会将整个图片加载到内存。
BitmapRegionDecoder decoder = null;
try {
decoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
} catch (IOException e) {
e.printStackTrace();
}
int width = rotation % 180 == 0 ? decoder.getWidth() : decoder.getHeight();
int height = rotation % 180 == 0 ? decoder.getHeight() : decoder.getWidth();
Rect frameRect = maskView.getFrameRectExtend();
int left = width * frameRect.left / maskView.getWidth();
int top = height * frameRect.top / maskView.getHeight();
int right = width * frameRect.right / maskView.getWidth();
int bottom = height * frameRect.bottom / maskView.getHeight();
// 高度大于图片
if (previewFrame.top < 0) {
// 宽度对齐。
int adjustedPreviewHeight = previewFrame.height() * getWidth() / previewFrame.width();
int topInFrame = ((adjustedPreviewHeight - frameRect.height()) / 2)
* getWidth() / previewFrame.width();
int bottomInFrame = ((adjustedPreviewHeight + frameRect.height()) / 2) * getWidth()
/ previewFrame.width();
// 等比例投射到照片当中。
top = topInFrame * height / previewFrame.height();
bottom = bottomInFrame * height / previewFrame.height();
} else {
// 宽度大于图片
if (previewFrame.left < 0) {
// 高度对齐
int adjustedPreviewWidth = previewFrame.width() * getHeight() / previewFrame.height();
int leftInFrame = ((adjustedPreviewWidth - maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
int rightInFrame = ((adjustedPreviewWidth + maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
// 等比例投射到照片当中。
left = leftInFrame * width / previewFrame.width();
right = rightInFrame * width / previewFrame.width();
}
}
Rect region = new Rect();
region.left = left;
region.top = top;
region.right = right;
region.bottom = bottom;
// 90度或者270度旋转
if (rotation % 180 == 90) {
int x = decoder.getWidth() / 2;
int y = decoder.getHeight() / 2;
int rotatedWidth = region.height();
int rotated = region.width();
// 计算，裁剪框旋转后的坐标
region.left = x - rotatedWidth / 2;
region.top = y - rotated / 2;
region.right = x + rotatedWidth / 2;
region.bottom = y + rotated / 2;
region.sort();
}
BitmapFactory.Options options = new BitmapFactory.Options();
// 最大图片大小。
int maxPreviewImageSize = 2560;
int size = Math.min(decoder.getWidth(), decoder.getHeight());
size = Math.min(size, maxPreviewImageSize);
options.inSampleSize = ImageUtil.calculateInSampleSize(options, size, size);
options.inScaled = true;
options.inDensity = Math.max(options.outWidth, options.outHeight);
options.inTargetDensity = size;
options.inPreferredConfig = Bitmap.Config.RGB_565;
Bitmap bitmap = decoder.decodeRegion(region, options);
if (rotation != 0) {
// 只能是裁剪完之后再旋转了。有没有别的更好的方案呢？
Matrix matrix = new Matrix();
matrix.postRotate(rotation);
Bitmap rotatedBitmap = Bitmap.createBitmap(
bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
if (bitmap != rotatedBitmap) {
// 有时候 createBitmap会复用对象
bitmap.recycle();
}
bitmap = rotatedBitmap;
}
final int status;
// 调用本地质量控制请求
switch (maskType) {
case MaskView.MASK_TYPE_ID_CARD_FRONT:
status = IDcardQualityProcess.getInstance().idcardQualityDetectionImg(bitmap, true);
break;
case MaskView.MASK_TYPE_ID_CARD_BACK:
status = IDcardQualityProcess.getInstance().idcardQualityDetectionImg(bitmap, false);
break;
default:
status = 1;
}
// 当有某个扫描处理线程调用成功后，阻止其他线程继续调用本地控制代码
if (status == SCAN_SUCCESS) {
// 扫描成功阻止多线程同时回调
if (!cameraControl.getAbortingScan().compareAndSet(false, true)) {
bitmap.recycle();
return 0;
}
autoPictureCallback.onPictureTaken(bitmap);
}
showTipMessage(status);
return status;
}
private void showTipMessage(final int status) {
// 提示tip文字变化
uiHandler.post(new Runnable() {
@Override
public void run() {
if (status == 0) {
hintViewText.setVisibility(View.INVISIBLE);
} else if (!cameraControl.getAbortingScan().get()) {
hintViewText.setVisibility(View.VISIBLE);
hintViewText.setText(getScanMessage(status));
}
}
});
}
private String getScanMessage(int status) {
String message;
switch (status) {
case 0:
message = "";
break;
case 2:
message = "身份证模糊，请重新尝试";
break;
case 3:
message = "身份证反光，请重新尝试";
break;
case 4:
message = "请将身份证前后反转再进行识别";
break;
case 5:
message = "请拿稳镜头和身份证";
break;
case 6:
message = "请将镜头靠近身份证";
break;
case 7:
message = "请将身份证完整置于取景框内";
break;
case NATIVE_AUTH_FAIL:
message = "本地质量控制授权失败";
break;
case NATIVE_INIT_FAIL:
message = "本地模型加载失败";
break;
case NATIVE_SOLOAD_FAIL:
message = "本地SO库加载失败";
break;
case 1:
default:
message = "请将身份证置于取景框内";
}
return message;
}
private void init() {
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
// cameraControl = new Camera2Control(getContext());
// } else {
//
// }
cameraControl = new Camera1Control(getContext());
displayView = cameraControl.getDisplayView();
addView(displayView);
maskView = new MaskView(getContext());
addView(maskView);
hintView = new ImageView(getContext());
addView(hintView);
hintViewTextWrapper = new LinearLayout(getContext());
hintViewTextWrapper.setOrientation(LinearLayout.VERTICAL);
LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
DimensionUtil.dpToPx(25));
lp.gravity = Gravity.CENTER;
hintViewText = new TextView(getContext());
hintViewText.setBackgroundResource(R.drawable.bd_ocr_round_corner);
hintViewText.setAlpha(0.5f);
hintViewText.setPadding(DimensionUtil.dpToPx(10), 0, DimensionUtil.dpToPx(10), 0);
hintViewTextWrapper.addView(hintViewText, lp);
hintViewText.setGravity(Gravity.CENTER);
hintViewText.setTextColor(Color.WHITE);
hintViewText.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14);
hintViewText.setText(getScanMessage(-1));
addView(hintViewTextWrapper, lp);
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
displayView.layout(left, 0, right, bottom - top);
maskView.layout(left, 0, right, bottom - top);
int hintViewWidth = DimensionUtil.dpToPx(250);
int hintViewHeight = DimensionUtil.dpToPx(25);
int hintViewLeft = (getWidth() - hintViewWidth) / 2;
int hintViewTop = maskView.getFrameRect().bottom + DimensionUtil.dpToPx(16);
hintViewTextWrapper.layout(hintViewLeft, hintViewTop,
hintViewLeft + hintViewWidth, hintViewTop + hintViewHeight);
hintView.layout(hintViewLeft, hintViewTop,
hintViewLeft + hintViewWidth, hintViewTop + hintViewHeight);
}
/**
* 拍摄后的照片。需要进行裁剪。有些手机（比如三星）不会对照片数据进行旋转，而是将旋转角度写入EXIF信息当中，
* 所以需要做旋转处理。
*
* @param outputFile 写入照片的文件。
* @param data 原始照片数据。
* @param rotation 照片exif中的旋转角度。
*
* @return 裁剪好的bitmap。
*/
@SuppressWarnings("ResultOfMethodCallIgnored")
private Bitmap crop(File outputFile, byte[] data, int rotation) {
try {
Rect previewFrame = cameraControl.getPreviewFrame();
if (maskView.getWidth() == 0 || maskView.getHeight() == 0
|| previewFrame.width() == 0 || previewFrame.height() == 0) {
return null;
}
// BitmapRegionDecoder不会将整个图片加载到内存。
BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
int width = rotation % 180 == 0 ? decoder.getWidth() : decoder.getHeight();
int height = rotation % 180 == 0 ? decoder.getHeight() : decoder.getWidth();
Rect frameRect = maskView.getFrameRect();
int left = width * frameRect.left / maskView.getWidth();
int top = height * frameRect.top / maskView.getHeight();
int right = width * frameRect.right / maskView.getWidth();
int bottom = height * frameRect.bottom / maskView.getHeight();
// 高度大于图片
if (previewFrame.top < 0) {
// 宽度对齐。
int adjustedPreviewHeight = previewFrame.height() * getWidth() / previewFrame.width();
int topInFrame = ((adjustedPreviewHeight - frameRect.height()) / 2)
* getWidth() / previewFrame.width();
int bottomInFrame = ((adjustedPreviewHeight + frameRect.height()) / 2) * getWidth()
/ previewFrame.width();
// 等比例投射到照片当中。
top = topInFrame * height / previewFrame.height();
bottom = bottomInFrame * height / previewFrame.height();
} else {
// 宽度大于图片
if (previewFrame.left < 0) {
// 高度对齐
int adjustedPreviewWidth = previewFrame.width() * getHeight() / previewFrame.height();
int leftInFrame = ((adjustedPreviewWidth - maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
int rightInFrame = ((adjustedPreviewWidth + maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
// 等比例投射到照片当中。
left = leftInFrame * width / previewFrame.width();
right = rightInFrame * width / previewFrame.width();
}
}
Rect region = new Rect();
region.left = left;
region.top = top;
region.right = right;
region.bottom = bottom;
// 90度或者270度旋转
if (rotation % 180 == 90) {
int x = decoder.getWidth() / 2;
int y = decoder.getHeight() / 2;
int rotatedWidth = region.height();
int rotated = region.width();
// 计算，裁剪框旋转后的坐标
region.left = x - rotatedWidth / 2;
region.top = y - rotated / 2;
region.right = x + rotatedWidth / 2;
region.bottom = y + rotated / 2;
region.sort();
}
BitmapFactory.Options options = new BitmapFactory.Options();
// 最大图片大小。
int maxPreviewImageSize = 2560;
int size = Math.min(decoder.getWidth(), decoder.getHeight());
size = Math.min(size, maxPreviewImageSize);
options.inSampleSize = ImageUtil.calculateInSampleSize(options, size, size);
options.inScaled = true;
options.inDensity = Math.max(options.outWidth, options.outHeight);
options.inTargetDensity = size;
options.inPreferredConfig = Bitmap.Config.RGB_565;
Bitmap bitmap = decoder.decodeRegion(region, options);
if (rotation != 0) {
// 只能是裁剪完之后再旋转了。有没有别的更好的方案呢？
Matrix matrix = new Matrix();
matrix.postRotate(rotation);
Bitmap rotatedBitmap = Bitmap.createBitmap(
bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
if (bitmap != rotatedBitmap) {
// 有时候 createBitmap会复用对象
bitmap.recycle();
}
bitmap = rotatedBitmap;
}
try {
if (!outputFile.exists()) {
outputFile.createNewFile();
}
FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fileOutputStream);
fileOutputStream.flush();
fileOutputStream.close();
return bitmap;
} catch (IOException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public void release() {
IDcardQualityProcess.getInstance().releaseModel();
}
private class CameraViewTakePictureCallback implements ICameraControl.OnTakePictureCallback {
private File file;
private OnTakePictureCallback callback;
@Override
public void onPictureTaken(final byte[] data) {
CameraThreadPool.execute(new Runnable() {
@Override
public void run() {
final int rotation = ImageUtil.getOrientation(data);
Bitmap bitmap = crop(file, data, rotation);
callback.onPictureTaken(bitmap);
}
});
}
}
}
| MZCretin/LotteryHelper | ocr_ui/src/main/java/com/baidu/ocr/ui/camera/CameraView.java | 5,152 | // 等比例投射到照片当中。 | line_comment | zh-cn | /*
* Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
*/
package com.baidu.ocr.ui.camera;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import com.baidu.idcardquality.IDcardQualityProcess;
import com.baidu.ocr.ui.R;
import com.baidu.ocr.ui.util.DimensionUtil;
import com.baidu.ocr.ui.util.ImageUtil;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapRegionDecoder;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.IntDef;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
/**
* 负责，相机的管理。同时提供，裁剪遮罩功能。
*/
public class CameraView extends FrameLayout {
private int maskType;
/**
* 照相回调
*/
interface OnTakePictureCallback {
void onPictureTaken(Bitmap bitmap);
}
/**
* 垂直方向 {@link #setOrientation(int)}
*/
public static final int ORIENTATION_PORTRAIT = 0;
/**
* 水平方向 {@link #setOrientation(int)}
*/
public static final int ORIENTATION_HORIZONTAL = 90;
/**
* 水平翻转方向 {@link #setOrientation(int)}
*/
public static final int ORIENTATION_INVERT = 270;
/**
* 本地模型授权，加载成功
*/
public static final int NATIVE_AUTH_INIT_SUCCESS = 0;
/**
* 本地模型授权，缺少SO
*/
public static final int NATIVE_SOLOAD_FAIL = 10;
/**
* 本地模型授权，授权失败，token异常
*/
public static final int NATIVE_AUTH_FAIL = 11;
/**
* 本地模型授权，模型加载失败
*/
public static final int NATIVE_INIT_FAIL = 12;
/**
* 是否已经通过本地质量控制扫描
*/
private final int SCAN_SUCCESS = 0;
public void setInitNativeStatus(int initNativeStatus) {
this.initNativeStatus = initNativeStatus;
}
/**
* 本地检测初始化，模型加载标识
*/
private int initNativeStatus = NATIVE_AUTH_INIT_SUCCESS;
@IntDef({ORIENTATION_PORTRAIT, ORIENTATION_HORIZONTAL, ORIENTATION_INVERT})
public @interface Orientation {
}
private CameraViewTakePictureCallback cameraViewTakePictureCallback = new CameraViewTakePictureCallback();
private ICameraControl cameraControl;
/**
* 相机预览View
*/
private View displayView;
/**
* 身份证，银行卡，等裁剪用的遮罩
*/
private MaskView maskView;
/**
* 用于显示提示证 "请对齐身份证正面" 之类的背景
*/
private ImageView hintView;
/**
* 用于显示提示证 "请对齐身份证正面" 之类的文字
*/
private TextView hintViewText;
/**
* 提示文案容器
*/
private LinearLayout hintViewTextWrapper;
/**
* 是否是本地质量控制扫描
*/
private boolean isEnableScan;
public void setEnableScan(boolean enableScan) {
isEnableScan = enableScan;
}
/**
* UI线程的handler
*/
Handler uiHandler = new Handler(Looper.getMainLooper());
public ICameraControl getCameraControl() {
return cameraControl;
}
public void setOrientation(@Orientation int orientation) {
cameraControl.setDisplayOrientation(orientation);
}
public CameraView(Context context) {
super(context);
init();
}
public CameraView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public CameraView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init();
}
public void start() {
cameraControl.start();
setKeepScreenOn(true);
}
public void stop() {
cameraControl.stop();
setKeepScreenOn(false);
}
public void takePicture(final File file, final OnTakePictureCallback callback) {
cameraViewTakePictureCallback.file = file;
cameraViewTakePictureCallback.callback = callback;
cameraControl.takePicture(cameraViewTakePictureCallback);
}
private OnTakePictureCallback autoPictureCallback;
public void setAutoPictureCallback(OnTakePictureCallback callback) {
autoPictureCallback = callback;
}
public void setMaskType(@MaskView.MaskType int maskType, final Context ctx) {
maskView.setMaskType(maskType);
maskView.setVisibility(VISIBLE);
hintView.setVisibility(VISIBLE);
int hintResourceId = R.drawable.bd_ocr_hint_align_id_card;
this.maskType = maskType;
boolean isNeedSetImage = true;
switch (maskType) {
case MaskView.MASK_TYPE_ID_CARD_FRONT:
hintResourceId = R.drawable.bd_ocr_round_corner;
isNeedSetImage = false;
break;
case MaskView.MASK_TYPE_ID_CARD_BACK:
isNeedSetImage = false;
hintResourceId = R.drawable.bd_ocr_round_corner;
break;
case MaskView.MASK_TYPE_BANK_CARD:
hintResourceId = R.drawable.bd_ocr_hint_align_bank_card;
break;
case MaskView.MASK_TYPE_NONE:
default:
maskView.setVisibility(INVISIBLE);
hintView.setVisibility(INVISIBLE);
break;
}
if (isNeedSetImage) {
hintView.setImageResource(hintResourceId);
hintViewTextWrapper.setVisibility(INVISIBLE);
}
if (maskType == MaskView.MASK_TYPE_ID_CARD_FRONT && isEnableScan) {
cameraControl.setDetectCallback(new ICameraControl.OnDetectPictureCallback() {
@Override
public int onDetect(byte[] data, int rotation) {
return detect(data, rotation);
}
});
}
if (maskType == MaskView.MASK_TYPE_ID_CARD_BACK && isEnableScan) {
cameraControl.setDetectCallback(new ICameraControl.OnDetectPictureCallback() {
@Override
public int onDetect(byte[] data, int rotation) {
return detect(data, rotation);
}
});
}
}
private int detect(byte[] data, final int rotation) {
if (initNativeStatus != NATIVE_AUTH_INIT_SUCCESS) {
showTipMessage(initNativeStatus);
return 1;
}
// 扫描成功阻止多余的操作
if (cameraControl.getAbortingScan().get()) {
return 0;
}
Rect previewFrame = cameraControl.getPreviewFrame();
if (maskView.getWidth() == 0 || maskView.getHeight() == 0
|| previewFrame.width() == 0 || previewFrame.height() == 0) {
return 0;
}
// BitmapRegionDecoder不会将整个图片加载到内存。
BitmapRegionDecoder decoder = null;
try {
decoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
} catch (IOException e) {
e.printStackTrace();
}
int width = rotation % 180 == 0 ? decoder.getWidth() : decoder.getHeight();
int height = rotation % 180 == 0 ? decoder.getHeight() : decoder.getWidth();
Rect frameRect = maskView.getFrameRectExtend();
int left = width * frameRect.left / maskView.getWidth();
int top = height * frameRect.top / maskView.getHeight();
int right = width * frameRect.right / maskView.getWidth();
int bottom = height * frameRect.bottom / maskView.getHeight();
// 高度大于图片
if (previewFrame.top < 0) {
// 宽度对齐。
int adjustedPreviewHeight = previewFrame.height() * getWidth() / previewFrame.width();
int topInFrame = ((adjustedPreviewHeight - frameRect.height()) / 2)
* getWidth() / previewFrame.width();
int bottomInFrame = ((adjustedPreviewHeight + frameRect.height()) / 2) * getWidth()
/ previewFrame.width();
// 等比例投射到照片当中。
top = topInFrame * height / previewFrame.height();
bottom = bottomInFrame * height / previewFrame.height();
} else {
// 宽度大于图片
if (previewFrame.left < 0) {
// 高度对齐
int adjustedPreviewWidth = previewFrame.width() * getHeight() / previewFrame.height();
int leftInFrame = ((adjustedPreviewWidth - maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
int rightInFrame = ((adjustedPreviewWidth + maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
// 等比例投射到照片当中。
left = leftInFrame * width / previewFrame.width();
right = rightInFrame * width / previewFrame.width();
}
}
Rect region = new Rect();
region.left = left;
region.top = top;
region.right = right;
region.bottom = bottom;
// 90度或者270度旋转
if (rotation % 180 == 90) {
int x = decoder.getWidth() / 2;
int y = decoder.getHeight() / 2;
int rotatedWidth = region.height();
int rotated = region.width();
// 计算，裁剪框旋转后的坐标
region.left = x - rotatedWidth / 2;
region.top = y - rotated / 2;
region.right = x + rotatedWidth / 2;
region.bottom = y + rotated / 2;
region.sort();
}
BitmapFactory.Options options = new BitmapFactory.Options();
// 最大图片大小。
int maxPreviewImageSize = 2560;
int size = Math.min(decoder.getWidth(), decoder.getHeight());
size = Math.min(size, maxPreviewImageSize);
options.inSampleSize = ImageUtil.calculateInSampleSize(options, size, size);
options.inScaled = true;
options.inDensity = Math.max(options.outWidth, options.outHeight);
options.inTargetDensity = size;
options.inPreferredConfig = Bitmap.Config.RGB_565;
Bitmap bitmap = decoder.decodeRegion(region, options);
if (rotation != 0) {
// 只能是裁剪完之后再旋转了。有没有别的更好的方案呢？
Matrix matrix = new Matrix();
matrix.postRotate(rotation);
Bitmap rotatedBitmap = Bitmap.createBitmap(
bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
if (bitmap != rotatedBitmap) {
// 有时候 createBitmap会复用对象
bitmap.recycle();
}
bitmap = rotatedBitmap;
}
final int status;
// 调用本地质量控制请求
switch (maskType) {
case MaskView.MASK_TYPE_ID_CARD_FRONT:
status = IDcardQualityProcess.getInstance().idcardQualityDetectionImg(bitmap, true);
break;
case MaskView.MASK_TYPE_ID_CARD_BACK:
status = IDcardQualityProcess.getInstance().idcardQualityDetectionImg(bitmap, false);
break;
default:
status = 1;
}
// 当有某个扫描处理线程调用成功后，阻止其他线程继续调用本地控制代码
if (status == SCAN_SUCCESS) {
// 扫描成功阻止多线程同时回调
if (!cameraControl.getAbortingScan().compareAndSet(false, true)) {
bitmap.recycle();
return 0;
}
autoPictureCallback.onPictureTaken(bitmap);
}
showTipMessage(status);
return status;
}
private void showTipMessage(final int status) {
// 提示tip文字变化
uiHandler.post(new Runnable() {
@Override
public void run() {
if (status == 0) {
hintViewText.setVisibility(View.INVISIBLE);
} else if (!cameraControl.getAbortingScan().get()) {
hintViewText.setVisibility(View.VISIBLE);
hintViewText.setText(getScanMessage(status));
}
}
});
}
private String getScanMessage(int status) {
String message;
switch (status) {
case 0:
message = "";
break;
case 2:
message = "身份证模糊，请重新尝试";
break;
case 3:
message = "身份证反光，请重新尝试";
break;
case 4:
message = "请将身份证前后反转再进行识别";
break;
case 5:
message = "请拿稳镜头和身份证";
break;
case 6:
message = "请将镜头靠近身份证";
break;
case 7:
message = "请将身份证完整置于取景框内";
break;
case NATIVE_AUTH_FAIL:
message = "本地质量控制授权失败";
break;
case NATIVE_INIT_FAIL:
message = "本地模型加载失败";
break;
case NATIVE_SOLOAD_FAIL:
message = "本地SO库加载失败";
break;
case 1:
default:
message = "请将身份证置于取景框内";
}
return message;
}
private void init() {
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
// cameraControl = new Camera2Control(getContext());
// } else {
//
// }
cameraControl = new Camera1Control(getContext());
displayView = cameraControl.getDisplayView();
addView(displayView);
maskView = new MaskView(getContext());
addView(maskView);
hintView = new ImageView(getContext());
addView(hintView);
hintViewTextWrapper = new LinearLayout(getContext());
hintViewTextWrapper.setOrientation(LinearLayout.VERTICAL);
LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(LayoutParams.WRAP_CONTENT,
DimensionUtil.dpToPx(25));
lp.gravity = Gravity.CENTER;
hintViewText = new TextView(getContext());
hintViewText.setBackgroundResource(R.drawable.bd_ocr_round_corner);
hintViewText.setAlpha(0.5f);
hintViewText.setPadding(DimensionUtil.dpToPx(10), 0, DimensionUtil.dpToPx(10), 0);
hintViewTextWrapper.addView(hintViewText, lp);
hintViewText.setGravity(Gravity.CENTER);
hintViewText.setTextColor(Color.WHITE);
hintViewText.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14);
hintViewText.setText(getScanMessage(-1));
addView(hintViewTextWrapper, lp);
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
displayView.layout(left, 0, right, bottom - top);
maskView.layout(left, 0, right, bottom - top);
int hintViewWidth = DimensionUtil.dpToPx(250);
int hintViewHeight = DimensionUtil.dpToPx(25);
int hintViewLeft = (getWidth() - hintViewWidth) / 2;
int hintViewTop = maskView.getFrameRect().bottom + DimensionUtil.dpToPx(16);
hintViewTextWrapper.layout(hintViewLeft, hintViewTop,
hintViewLeft + hintViewWidth, hintViewTop + hintViewHeight);
hintView.layout(hintViewLeft, hintViewTop,
hintViewLeft + hintViewWidth, hintViewTop + hintViewHeight);
}
/**
* 拍摄后的照片。需要进行裁剪。有些手机（比如三星）不会对照片数据进行旋转，而是将旋转角度写入EXIF信息当中，
* 所以需要做旋转处理。
*
* @param outputFile 写入照片的文件。
* @param data 原始照片数据。
* @param rotation 照片exif中的旋转角度。
*
* @return 裁剪好的bitmap。
*/
@SuppressWarnings("ResultOfMethodCallIgnored")
private Bitmap crop(File outputFile, byte[] data, int rotation) {
try {
Rect previewFrame = cameraControl.getPreviewFrame();
if (maskView.getWidth() == 0 || maskView.getHeight() == 0
|| previewFrame.width() == 0 || previewFrame.height() == 0) {
return null;
}
// BitmapRegionDecoder不会将整个图片加载到内存。
BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
int width = rotation % 180 == 0 ? decoder.getWidth() : decoder.getHeight();
int height = rotation % 180 == 0 ? decoder.getHeight() : decoder.getWidth();
Rect frameRect = maskView.getFrameRect();
int left = width * frameRect.left / maskView.getWidth();
int top = height * frameRect.top / maskView.getHeight();
int right = width * frameRect.right / maskView.getWidth();
int bottom = height * frameRect.bottom / maskView.getHeight();
// 高度大于图片
if (previewFrame.top < 0) {
// 宽度对齐。
int adjustedPreviewHeight = previewFrame.height() * getWidth() / previewFrame.width();
int topInFrame = ((adjustedPreviewHeight - frameRect.height()) / 2)
* getWidth() / previewFrame.width();
int bottomInFrame = ((adjustedPreviewHeight + frameRect.height()) / 2) * getWidth()
/ previewFrame.width();
// 等比 <SUF>
top = topInFrame * height / previewFrame.height();
bottom = bottomInFrame * height / previewFrame.height();
} else {
// 宽度大于图片
if (previewFrame.left < 0) {
// 高度对齐
int adjustedPreviewWidth = previewFrame.width() * getHeight() / previewFrame.height();
int leftInFrame = ((adjustedPreviewWidth - maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
int rightInFrame = ((adjustedPreviewWidth + maskView.getFrameRect().width()) / 2) * getHeight()
/ previewFrame.height();
// 等比例投射到照片当中。
left = leftInFrame * width / previewFrame.width();
right = rightInFrame * width / previewFrame.width();
}
}
Rect region = new Rect();
region.left = left;
region.top = top;
region.right = right;
region.bottom = bottom;
// 90度或者270度旋转
if (rotation % 180 == 90) {
int x = decoder.getWidth() / 2;
int y = decoder.getHeight() / 2;
int rotatedWidth = region.height();
int rotated = region.width();
// 计算，裁剪框旋转后的坐标
region.left = x - rotatedWidth / 2;
region.top = y - rotated / 2;
region.right = x + rotatedWidth / 2;
region.bottom = y + rotated / 2;
region.sort();
}
BitmapFactory.Options options = new BitmapFactory.Options();
// 最大图片大小。
int maxPreviewImageSize = 2560;
int size = Math.min(decoder.getWidth(), decoder.getHeight());
size = Math.min(size, maxPreviewImageSize);
options.inSampleSize = ImageUtil.calculateInSampleSize(options, size, size);
options.inScaled = true;
options.inDensity = Math.max(options.outWidth, options.outHeight);
options.inTargetDensity = size;
options.inPreferredConfig = Bitmap.Config.RGB_565;
Bitmap bitmap = decoder.decodeRegion(region, options);
if (rotation != 0) {
// 只能是裁剪完之后再旋转了。有没有别的更好的方案呢？
Matrix matrix = new Matrix();
matrix.postRotate(rotation);
Bitmap rotatedBitmap = Bitmap.createBitmap(
bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
if (bitmap != rotatedBitmap) {
// 有时候 createBitmap会复用对象
bitmap.recycle();
}
bitmap = rotatedBitmap;
}
try {
if (!outputFile.exists()) {
outputFile.createNewFile();
}
FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
bitmap.compress(Bitmap.CompressFormat.JPEG, 90, fileOutputStream);
fileOutputStream.flush();
fileOutputStream.close();
return bitmap;
} catch (IOException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public void release() {
IDcardQualityProcess.getInstance().releaseModel();
}
private class CameraViewTakePictureCallback implements ICameraControl.OnTakePictureCallback {
private File file;
private OnTakePictureCallback callback;
@Override
public void onPictureTaken(final byte[] data) {
CameraThreadPool.execute(new Runnable() {
@Override
public void run() {
final int rotation = ImageUtil.getOrientation(data);
Bitmap bitmap = crop(file, data, rotation);
callback.onPictureTaken(bitmap);
}
});
}
}
}
| true |
60031_38 | package com.cretin.www.wheelsruflibrary.view;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Build;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import com.cretin.www.wheelsruflibrary.R;
import com.cretin.www.wheelsruflibrary.listener.RotateListener;
import java.util.ArrayList;
import java.util.List;
/**
* Created by cretin on 2017/12/26.
*/
public class WheelSurfView extends RelativeLayout {
//当前的圆盘VIew
private WheelSurfPanView mWheelSurfPanView;
//Context
private Context mContext;
//开始按钮
private ImageView mStart;
//动画回调监听
private RotateListener rotateListener;
public void setRotateListener(RotateListener rotateListener) {
mWheelSurfPanView.setRotateListener(rotateListener);
this.rotateListener = rotateListener;
}
public WheelSurfView(Context context) {
super(context);
init(context, null);
}
public WheelSurfView(Context context, AttributeSet attrs) {
super(context, attrs);
init(context, attrs);
}
public WheelSurfView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context, attrs);
}
//开始抽奖的图标
private Integer mGoImgRes;
private void init(Context context, AttributeSet attrs) {
mContext = context;
if ( attrs != null ) {
//获得这个控件对应的属性。
TypedArray typedArray = getContext().obtainStyledAttributes(attrs, R.styleable.wheelSurfView);
try {
mGoImgRes = typedArray.getResourceId(R.styleable.wheelSurfView_goImg, 0);
} finally { //回收这个对象
typedArray.recycle();
}
}
//添加圆盘视图
mWheelSurfPanView = new WheelSurfPanView(mContext, attrs);
RelativeLayout.LayoutParams layoutParams =
new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT);
mWheelSurfPanView.setLayoutParams(layoutParams);
addView(mWheelSurfPanView);
//添加开始按钮
mStart = new ImageView(mContext);
//如果用户没有设置自定义的图标就使用默认的
if ( mGoImgRes == 0 ) {
mStart.setImageResource(R.mipmap.node);
} else {
mStart.setImageResource(mGoImgRes);
}
//给图片设置LayoutParams
RelativeLayout.LayoutParams llStart =
new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
llStart.addRule(RelativeLayout.CENTER_IN_PARENT);
mStart.setLayoutParams(llStart);
addView(mStart);
mStart.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//调用此方法是将主动权交个调用者 由调用者调用开始旋转的方法
if ( rotateListener != null )
rotateListener.rotateBefore(( ImageView ) v);
}
});
}
public void setConfig(Builder builder) {
if ( builder.mColors != null )
mWheelSurfPanView.setmColors(builder.mColors);
if ( builder.mDeses != null )
mWheelSurfPanView.setmDeses(builder.mDeses);
if ( builder.mHuanImgRes != 0 )
mWheelSurfPanView.setmHuanImgRes(builder.mHuanImgRes);
if ( builder.mIcons != null )
mWheelSurfPanView.setmIcons(builder.mIcons);
if ( builder.mMainImgRes != 0 )
mWheelSurfPanView.setmMainImgRes(builder.mMainImgRes);
if ( builder.mMinTimes != 0 )
mWheelSurfPanView.setmMinTimes(builder.mMinTimes);
if ( builder.mTextColor != 0 )
mWheelSurfPanView.setmTextColor(builder.mTextColor);
if ( builder.mTextSize != 0 )
mWheelSurfPanView.setmTextSize(builder.mTextSize);
if ( builder.mType != 0 )
mWheelSurfPanView.setmType(builder.mType);
if ( builder.mVarTime != 0 )
mWheelSurfPanView.setmVarTime(builder.mVarTime);
if ( builder.mTypeNum != 0 )
mWheelSurfPanView.setmTypeNum(builder.mTypeNum);
mWheelSurfPanView.show();
}
/**
* 开始旋转
*
* @param pisition 旋转最终的位置 注意 从1 开始 而且是逆时针递增
*/
public void startRotate(int pisition) {
if ( mWheelSurfPanView != null ) {
mWheelSurfPanView.startRotate(pisition);
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//视图是个正方形的 所以有宽就足够了 默认值是500 也就是WRAP_CONTENT的时候
setMeasuredDimension(getDefaultSize(0, widthMeasureSpec), getDefaultSize(0, heightMeasureSpec));
// Children are just made to fill our space.
final int childWidthSize = getMeasuredWidth();
//高度和宽度一样
heightMeasureSpec = widthMeasureSpec = MeasureSpec.makeMeasureSpec(childWidthSize, MeasureSpec.EXACTLY);
//onMeasure调用获取到当前视图大小之后，
// 手动按照一定的比例计算出中间开始按钮的大小，
// 再设置给那个按钮，免得造成用户传的图片不合适之后显示贼难看
// 只设置一次
if ( isFirst ) {
isFirst = !isFirst;
//获取中间按钮的大小
ViewTreeObserver vto = mStart.getViewTreeObserver();
vto.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@TargetApi( Build.VERSION_CODES.KITKAT )
@Override
public void onGlobalLayout() {
mStart.getViewTreeObserver().removeGlobalOnLayoutListener(this);
float w = mStart.getMeasuredWidth();
float h = mStart.getMeasuredHeight();
//计算新的大小 默认为整个大小最大值的0.17 至于为什么是0.17 我只想说我乐意。。。。
int newW = ( int ) ((( float ) childWidthSize) * 0.17);
int newH = ( int ) ((( float ) childWidthSize) * 0.17 * h / w);
ViewGroup.LayoutParams layoutParams = mStart.getLayoutParams();
layoutParams.width = newW;
layoutParams.height = newH;
mStart.setLayoutParams(layoutParams);
}
});
}
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
//记录当前是否是第一次回调onMeasure
private boolean isFirst = true;
//建造者模式
public static final class Builder {
//当前类型 1 自定义模式 2 暴力模式
private int mType = 0;
//最低圈数 默认值3 也就是说每次旋转都会最少转3圈
private int mMinTimes = 0;
//分类数量 如果数量为负数 通过代码设置样式
private int mTypeNum = 0;
//每个扇形旋转的时间
private int mVarTime = 0;
//文字描述集合
private String[] mDeses;
//自定义图标集合
private List<Bitmap> mIcons;
//背景颜色
private Integer[] mColors;
//整个旋转图的背景 只有类型为2时才需要
private Integer mMainImgRes = 0;
//GO图标
private Integer mGoImgRes = 0;
//圆环的图片引用
private Integer mHuanImgRes = 0;
//文字大小
private float mTextSize = 0;
//文字颜色
private int mTextColor = 0;
public final WheelSurfView.Builder setmType(int mType) {
this.mType = mType;
return this;
}
public final WheelSurfView.Builder setmTypeNum(int mTypeNum) {
this.mTypeNum = mTypeNum;
return this;
}
public final WheelSurfView.Builder setmGoImgRes(int mGoImgRes) {
this.mGoImgRes = mGoImgRes;
return this;
}
public final WheelSurfView.Builder setmMinTimes(int mMinTimes) {
this.mMinTimes = mMinTimes;
return this;
}
public final WheelSurfView.Builder setmVarTime(int mVarTime) {
this.mVarTime = mVarTime;
return this;
}
public final WheelSurfView.Builder setmDeses(String[] mDeses) {
this.mDeses = mDeses;
return this;
}
public final WheelSurfView.Builder setmIcons(List<Bitmap> mIcons) {
this.mIcons = mIcons;
return this;
}
public final WheelSurfView.Builder setmColors(Integer[] mColors) {
this.mColors = mColors;
return this;
}
public final WheelSurfView.Builder setmMainImgRes(Integer mMainImgRes) {
this.mMainImgRes = mMainImgRes;
return this;
}
public final WheelSurfView.Builder setmHuanImgRes(Integer mHuanImgRes) {
this.mHuanImgRes = mHuanImgRes;
return this;
}
public final WheelSurfView.Builder setmTextSize(float mTextSize) {
this.mTextSize = mTextSize;
return this;
}
public final WheelSurfView.Builder setmTextColor(int mTextColor) {
this.mTextColor = mTextColor;
return this;
}
public final Builder build() {
return this;
}
}
//旋转图片
public static List<Bitmap> rotateBitmaps(List<Bitmap> source) {
float mAngle = ( float ) (360.0 / source.size());
List<Bitmap> result = new ArrayList<>();
for ( int i = 0; i < source.size(); i++ ) {
Bitmap bitmap = source.get(i);
int ww = bitmap.getWidth();
int hh = bitmap.getHeight();
// 定义矩阵对象
Matrix matrix = new Matrix();
// 缩放原图
matrix.postScale(1f, 1f);
// 向左旋转45度，参数为正则向右旋转
matrix.postRotate(mAngle * i);
//bmp.getWidth(), 500分别表示重绘后的位图宽高
Bitmap dstbmp = Bitmap.createBitmap(bitmap, 0, 0, ww, hh,
matrix, true);
result.add(dstbmp);
}
return result;
}
}
| MZCretin/WheelSurfDemo | wheelsruflibrary/src/main/java/com/cretin/www/wheelsruflibrary/view/WheelSurfView.java | 2,704 | // 定义矩阵对象 | line_comment | zh-cn | package com.cretin.www.wheelsruflibrary.view;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Build;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import com.cretin.www.wheelsruflibrary.R;
import com.cretin.www.wheelsruflibrary.listener.RotateListener;
import java.util.ArrayList;
import java.util.List;
/**
* Created by cretin on 2017/12/26.
*/
public class WheelSurfView extends RelativeLayout {
//当前的圆盘VIew
private WheelSurfPanView mWheelSurfPanView;
//Context
private Context mContext;
//开始按钮
private ImageView mStart;
//动画回调监听
private RotateListener rotateListener;
public void setRotateListener(RotateListener rotateListener) {
mWheelSurfPanView.setRotateListener(rotateListener);
this.rotateListener = rotateListener;
}
public WheelSurfView(Context context) {
super(context);
init(context, null);
}
public WheelSurfView(Context context, AttributeSet attrs) {
super(context, attrs);
init(context, attrs);
}
public WheelSurfView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context, attrs);
}
//开始抽奖的图标
private Integer mGoImgRes;
private void init(Context context, AttributeSet attrs) {
mContext = context;
if ( attrs != null ) {
//获得这个控件对应的属性。
TypedArray typedArray = getContext().obtainStyledAttributes(attrs, R.styleable.wheelSurfView);
try {
mGoImgRes = typedArray.getResourceId(R.styleable.wheelSurfView_goImg, 0);
} finally { //回收这个对象
typedArray.recycle();
}
}
//添加圆盘视图
mWheelSurfPanView = new WheelSurfPanView(mContext, attrs);
RelativeLayout.LayoutParams layoutParams =
new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT);
mWheelSurfPanView.setLayoutParams(layoutParams);
addView(mWheelSurfPanView);
//添加开始按钮
mStart = new ImageView(mContext);
//如果用户没有设置自定义的图标就使用默认的
if ( mGoImgRes == 0 ) {
mStart.setImageResource(R.mipmap.node);
} else {
mStart.setImageResource(mGoImgRes);
}
//给图片设置LayoutParams
RelativeLayout.LayoutParams llStart =
new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
llStart.addRule(RelativeLayout.CENTER_IN_PARENT);
mStart.setLayoutParams(llStart);
addView(mStart);
mStart.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//调用此方法是将主动权交个调用者 由调用者调用开始旋转的方法
if ( rotateListener != null )
rotateListener.rotateBefore(( ImageView ) v);
}
});
}
public void setConfig(Builder builder) {
if ( builder.mColors != null )
mWheelSurfPanView.setmColors(builder.mColors);
if ( builder.mDeses != null )
mWheelSurfPanView.setmDeses(builder.mDeses);
if ( builder.mHuanImgRes != 0 )
mWheelSurfPanView.setmHuanImgRes(builder.mHuanImgRes);
if ( builder.mIcons != null )
mWheelSurfPanView.setmIcons(builder.mIcons);
if ( builder.mMainImgRes != 0 )
mWheelSurfPanView.setmMainImgRes(builder.mMainImgRes);
if ( builder.mMinTimes != 0 )
mWheelSurfPanView.setmMinTimes(builder.mMinTimes);
if ( builder.mTextColor != 0 )
mWheelSurfPanView.setmTextColor(builder.mTextColor);
if ( builder.mTextSize != 0 )
mWheelSurfPanView.setmTextSize(builder.mTextSize);
if ( builder.mType != 0 )
mWheelSurfPanView.setmType(builder.mType);
if ( builder.mVarTime != 0 )
mWheelSurfPanView.setmVarTime(builder.mVarTime);
if ( builder.mTypeNum != 0 )
mWheelSurfPanView.setmTypeNum(builder.mTypeNum);
mWheelSurfPanView.show();
}
/**
* 开始旋转
*
* @param pisition 旋转最终的位置 注意 从1 开始 而且是逆时针递增
*/
public void startRotate(int pisition) {
if ( mWheelSurfPanView != null ) {
mWheelSurfPanView.startRotate(pisition);
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//视图是个正方形的 所以有宽就足够了 默认值是500 也就是WRAP_CONTENT的时候
setMeasuredDimension(getDefaultSize(0, widthMeasureSpec), getDefaultSize(0, heightMeasureSpec));
// Children are just made to fill our space.
final int childWidthSize = getMeasuredWidth();
//高度和宽度一样
heightMeasureSpec = widthMeasureSpec = MeasureSpec.makeMeasureSpec(childWidthSize, MeasureSpec.EXACTLY);
//onMeasure调用获取到当前视图大小之后，
// 手动按照一定的比例计算出中间开始按钮的大小，
// 再设置给那个按钮，免得造成用户传的图片不合适之后显示贼难看
// 只设置一次
if ( isFirst ) {
isFirst = !isFirst;
//获取中间按钮的大小
ViewTreeObserver vto = mStart.getViewTreeObserver();
vto.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@TargetApi( Build.VERSION_CODES.KITKAT )
@Override
public void onGlobalLayout() {
mStart.getViewTreeObserver().removeGlobalOnLayoutListener(this);
float w = mStart.getMeasuredWidth();
float h = mStart.getMeasuredHeight();
//计算新的大小 默认为整个大小最大值的0.17 至于为什么是0.17 我只想说我乐意。。。。
int newW = ( int ) ((( float ) childWidthSize) * 0.17);
int newH = ( int ) ((( float ) childWidthSize) * 0.17 * h / w);
ViewGroup.LayoutParams layoutParams = mStart.getLayoutParams();
layoutParams.width = newW;
layoutParams.height = newH;
mStart.setLayoutParams(layoutParams);
}
});
}
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
//记录当前是否是第一次回调onMeasure
private boolean isFirst = true;
//建造者模式
public static final class Builder {
//当前类型 1 自定义模式 2 暴力模式
private int mType = 0;
//最低圈数 默认值3 也就是说每次旋转都会最少转3圈
private int mMinTimes = 0;
//分类数量 如果数量为负数 通过代码设置样式
private int mTypeNum = 0;
//每个扇形旋转的时间
private int mVarTime = 0;
//文字描述集合
private String[] mDeses;
//自定义图标集合
private List<Bitmap> mIcons;
//背景颜色
private Integer[] mColors;
//整个旋转图的背景 只有类型为2时才需要
private Integer mMainImgRes = 0;
//GO图标
private Integer mGoImgRes = 0;
//圆环的图片引用
private Integer mHuanImgRes = 0;
//文字大小
private float mTextSize = 0;
//文字颜色
private int mTextColor = 0;
public final WheelSurfView.Builder setmType(int mType) {
this.mType = mType;
return this;
}
public final WheelSurfView.Builder setmTypeNum(int mTypeNum) {
this.mTypeNum = mTypeNum;
return this;
}
public final WheelSurfView.Builder setmGoImgRes(int mGoImgRes) {
this.mGoImgRes = mGoImgRes;
return this;
}
public final WheelSurfView.Builder setmMinTimes(int mMinTimes) {
this.mMinTimes = mMinTimes;
return this;
}
public final WheelSurfView.Builder setmVarTime(int mVarTime) {
this.mVarTime = mVarTime;
return this;
}
public final WheelSurfView.Builder setmDeses(String[] mDeses) {
this.mDeses = mDeses;
return this;
}
public final WheelSurfView.Builder setmIcons(List<Bitmap> mIcons) {
this.mIcons = mIcons;
return this;
}
public final WheelSurfView.Builder setmColors(Integer[] mColors) {
this.mColors = mColors;
return this;
}
public final WheelSurfView.Builder setmMainImgRes(Integer mMainImgRes) {
this.mMainImgRes = mMainImgRes;
return this;
}
public final WheelSurfView.Builder setmHuanImgRes(Integer mHuanImgRes) {
this.mHuanImgRes = mHuanImgRes;
return this;
}
public final WheelSurfView.Builder setmTextSize(float mTextSize) {
this.mTextSize = mTextSize;
return this;
}
public final WheelSurfView.Builder setmTextColor(int mTextColor) {
this.mTextColor = mTextColor;
return this;
}
public final Builder build() {
return this;
}
}
//旋转图片
public static List<Bitmap> rotateBitmaps(List<Bitmap> source) {
float mAngle = ( float ) (360.0 / source.size());
List<Bitmap> result = new ArrayList<>();
for ( int i = 0; i < source.size(); i++ ) {
Bitmap bitmap = source.get(i);
int ww = bitmap.getWidth();
int hh = bitmap.getHeight();
// 定义 <SUF>
Matrix matrix = new Matrix();
// 缩放原图
matrix.postScale(1f, 1f);
// 向左旋转45度，参数为正则向右旋转
matrix.postRotate(mAngle * i);
//bmp.getWidth(), 500分别表示重绘后的位图宽高
Bitmap dstbmp = Bitmap.createBitmap(bitmap, 0, 0, ww, hh,
matrix, true);
result.add(dstbmp);
}
return result;
}
}
| false |
39725_0 | package thread;
public class ResortSeqDemo {
int a=0;
boolean flag=false;
/*
多线程下flag=true可能先执行，还没走到a=1就被挂起。
其它线程进入method02的判断，修改a的值=5，而不是6。
*/
public void method01(){
a=1;
flag=true;
}
public void method02(){
if (flag){
a+=5;
System.out.println("*****retValue: "+a);
}
}
}
| MaJesTySA/JVM-JUC-Core | src/thread/ResortSeqDemo.java | 130 | /*
多线程下flag=true可能先执行，还没走到a=1就被挂起。
其它线程进入method02的判断，修改a的值=5，而不是6。
*/ | block_comment | zh-cn | package thread;
public class ResortSeqDemo {
int a=0;
boolean flag=false;
/*
多线程 <SUF>*/
public void method01(){
a=1;
flag=true;
}
public void method02(){
if (flag){
a+=5;
System.out.println("*****retValue: "+a);
}
}
}
| false |
37064_6 | import java.util.ArrayList;
import java.util.List;
public class Convert {
public static int convert(String s){
StringBuilder sb = new StringBuilder(s);
int count=1;
return toInt(sb, 0, count);
}
private static int toInt(StringBuilder sb, int target, int count){
if(sb.isEmpty()) return target;
char val = sb.charAt(sb.length()-1);
target += ((int) val - '0') * count;
count*=10;
sb.deleteCharAt(sb.length()-1);
return toInt( sb, target, count);
}
public static void main(String[] args){
String s = "1234567";
System.out.println(convert(s));
}
public static int computeSum(int[][] array, int row, int col) {
// 基本情况：当遍历到数组的最后一行时，返回当前行的和
if (row == array.length - 1) {
return computeRowSum(array[row]);
}
// 递归调用：计算当前行的和并加上下一行的递归结果
return computeRowSum(array[row]) + computeSum(array, row + 1, col);
}
// 计算一维数组中所有元素的和
private static int computeRowSum(int[] row) {
int sum = 0;
for (int num : row) {
sum += num;
}
return sum;
}
public static List<List<Integer>> generateSubsets(int[] elements, int index) {
// 基本情况：当索引达到数组的末尾时，返回一个包含空集的集合
if (index == elements.length) {
List<List<Integer>> result = new ArrayList<>();
result.add(new ArrayList<>()); // 空集
return result;
}
// 递归调用：生成包含当前元素的所有子集，并加上不包含当前元素的所有子集
int currentElement = elements[index];
List<List<Integer>> subsetsWithoutCurrent = generateSubsets(elements, index + 1);
List<List<Integer>> subsetsWithCurrent = new ArrayList<>();
for (List<Integer> subset : subsetsWithoutCurrent) {
List<Integer> subsetWithCurrent = new ArrayList<>(subset);
subsetWithCurrent.add(currentElement);
subsetsWithCurrent.add(subsetWithCurrent);
}
// 合并两个集合
subsetsWithoutCurrent.addAll(subsetsWithCurrent);
return subsetsWithoutCurrent;
}
public static boolean isPalindrome(String s) {
if (s.length() <= 1) {
return true;
}
char firstChar = s.charAt(0);
char lastChar = s.charAt(s.length() - 1);
return (firstChar == lastChar) && isPalindrome(s.substring(1, s.length() - 1));
}
public static boolean moreVowelsThanConsonants(String s) {
s = s.toLowerCase();
if (s.isEmpty()) {
return true;
}
char firstChar = s.charAt(0);
if (isVowel(firstChar)) {
return moreVowelsThanConsonants(s.substring(1));
} else {
return false;
}
}
private static boolean isVowel(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
public static void range(int[] array, int k){
rearrangeArray(array, k, 0, array.length - 1);
}
public static void rearrangeArray(int[] A, int k, int start, int end) {
if (start >= end) {
return;
}
while (start < end && A[start] <= k) {
start++;
}
while (start < end && A[end] > k) {
end--;
}
if (start < end) {
int temp = A[start];
A[start] = A[end];
A[end] = temp;
}
rearrangeArray(A, k, start, end);
}
public static boolean find(int[] array,int targetSum){
return findTwoSum(array, targetSum, 0, array.length - 1);
}
public static boolean findTwoSum(int[] A, int k, int start, int end) {
// 基本情况：索引范围越界，无法找到两个整数
if (start >= end) {
return false;
}
// 计算当前两个元素的和
int sum = A[start] + A[end];
// 如果和等于 k，则找到了两个整数，返回 true
if (sum == k) {
System.out.println("找到两个整数：" + A[start] + " 和 " + A[end]);
return true;
}
// 如果和小于 k，则递归查找右侧元素
if (sum < k) {
return findTwoSum(A, k, start + 1, end);
}
// 如果和大于 k，则递归查找左侧元素
return findTwoSum(A, k, start, end - 1);
}
public class ReverseLinkedList {
static class ListNode {
int value;
ListNode next;
public ListNode(int value) {
this.value = value;
}
}
// 递归反转单链表
public static ListNode reverseList(ListNode head) {
// 基本情况：空链表或只有一个节点
if (head == null || head.next == null) {
return head;
}
// 递归调用：反转后的头节点是原链表的尾节点
ListNode reversedHead = reverseList(head.next);
// 反转当前节点的指针
head.next.next = head;
head.next = null;
return reversedHead;
}
// 打印链表
public static void printList(ListNode head) {
while (head != null) {
System.out.print(head.value + " ");
head = head.next;
}
System.out.println();
}
}
}
| MaZhiyu1/Java_Algorithm | Convert.java | 1,417 | // 基本情况：索引范围越界，无法找到两个整数 | line_comment | zh-cn | import java.util.ArrayList;
import java.util.List;
public class Convert {
public static int convert(String s){
StringBuilder sb = new StringBuilder(s);
int count=1;
return toInt(sb, 0, count);
}
private static int toInt(StringBuilder sb, int target, int count){
if(sb.isEmpty()) return target;
char val = sb.charAt(sb.length()-1);
target += ((int) val - '0') * count;
count*=10;
sb.deleteCharAt(sb.length()-1);
return toInt( sb, target, count);
}
public static void main(String[] args){
String s = "1234567";
System.out.println(convert(s));
}
public static int computeSum(int[][] array, int row, int col) {
// 基本情况：当遍历到数组的最后一行时，返回当前行的和
if (row == array.length - 1) {
return computeRowSum(array[row]);
}
// 递归调用：计算当前行的和并加上下一行的递归结果
return computeRowSum(array[row]) + computeSum(array, row + 1, col);
}
// 计算一维数组中所有元素的和
private static int computeRowSum(int[] row) {
int sum = 0;
for (int num : row) {
sum += num;
}
return sum;
}
public static List<List<Integer>> generateSubsets(int[] elements, int index) {
// 基本情况：当索引达到数组的末尾时，返回一个包含空集的集合
if (index == elements.length) {
List<List<Integer>> result = new ArrayList<>();
result.add(new ArrayList<>()); // 空集
return result;
}
// 递归调用：生成包含当前元素的所有子集，并加上不包含当前元素的所有子集
int currentElement = elements[index];
List<List<Integer>> subsetsWithoutCurrent = generateSubsets(elements, index + 1);
List<List<Integer>> subsetsWithCurrent = new ArrayList<>();
for (List<Integer> subset : subsetsWithoutCurrent) {
List<Integer> subsetWithCurrent = new ArrayList<>(subset);
subsetWithCurrent.add(currentElement);
subsetsWithCurrent.add(subsetWithCurrent);
}
// 合并两个集合
subsetsWithoutCurrent.addAll(subsetsWithCurrent);
return subsetsWithoutCurrent;
}
public static boolean isPalindrome(String s) {
if (s.length() <= 1) {
return true;
}
char firstChar = s.charAt(0);
char lastChar = s.charAt(s.length() - 1);
return (firstChar == lastChar) && isPalindrome(s.substring(1, s.length() - 1));
}
public static boolean moreVowelsThanConsonants(String s) {
s = s.toLowerCase();
if (s.isEmpty()) {
return true;
}
char firstChar = s.charAt(0);
if (isVowel(firstChar)) {
return moreVowelsThanConsonants(s.substring(1));
} else {
return false;
}
}
private static boolean isVowel(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
public static void range(int[] array, int k){
rearrangeArray(array, k, 0, array.length - 1);
}
public static void rearrangeArray(int[] A, int k, int start, int end) {
if (start >= end) {
return;
}
while (start < end && A[start] <= k) {
start++;
}
while (start < end && A[end] > k) {
end--;
}
if (start < end) {
int temp = A[start];
A[start] = A[end];
A[end] = temp;
}
rearrangeArray(A, k, start, end);
}
public static boolean find(int[] array,int targetSum){
return findTwoSum(array, targetSum, 0, array.length - 1);
}
public static boolean findTwoSum(int[] A, int k, int start, int end) {
// 基本 <SUF>
if (start >= end) {
return false;
}
// 计算当前两个元素的和
int sum = A[start] + A[end];
// 如果和等于 k，则找到了两个整数，返回 true
if (sum == k) {
System.out.println("找到两个整数：" + A[start] + " 和 " + A[end]);
return true;
}
// 如果和小于 k，则递归查找右侧元素
if (sum < k) {
return findTwoSum(A, k, start + 1, end);
}
// 如果和大于 k，则递归查找左侧元素
return findTwoSum(A, k, start, end - 1);
}
public class ReverseLinkedList {
static class ListNode {
int value;
ListNode next;
public ListNode(int value) {
this.value = value;
}
}
// 递归反转单链表
public static ListNode reverseList(ListNode head) {
// 基本情况：空链表或只有一个节点
if (head == null || head.next == null) {
return head;
}
// 递归调用：反转后的头节点是原链表的尾节点
ListNode reversedHead = reverseList(head.next);
// 反转当前节点的指针
head.next.next = head;
head.next = null;
return reversedHead;
}
// 打印链表
public static void printList(ListNode head) {
while (head != null) {
System.out.print(head.value + " ");
head = head.next;
}
System.out.println();
}
}
}
| true |
380_3 | package com.iguigui.maaj.easySample;
import com.sun.jna.Pointer;
import com.sun.jna.win32.StdCallLibrary;
//本质上是对C接口的抽象层
//请参考C接口 https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/master/include/AsstCaller.h
public interface MaaCore extends StdCallLibrary {
//回调接口定义
interface AsstApiCallback extends StdCallCallback {
void callback(int msg, String detail_json, String custom_arg);
}
//第一步，加载资源
boolean AsstLoadResource(String path);
//选一个你喜欢的create，搞不定回调就用普通create，又不是不能用
Pointer AsstCreate();
/**
* 带回调的实例创建
* @param callback 回调方法实例
* @param custom_arg 用户参数，塞什么进去回头就给你回调的时候返回什么，例如填入自己生成的实例ID，回调回来就可以用于查询是哪个实例的回调信息
* @return
*/
Pointer AsstCreateEx(AsstApiCallback callback, String custom_arg);
//销毁实例释放连接
void AsstDestroy(Pointer handle);
//连接安卓
boolean AsstConnect(Pointer handle, String adb, String host, String config);
//添加任务链
//参考集成文档 https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/master/docs/3.1-%E9%9B%86%E6%88%90%E6%96%87%E6%A1%A3.md
int AsstAppendTask(Pointer handle, String type, String params);
//运行时修改参数
boolean AsstSetTaskParams(Pointer handle, int taskId, String params);
//开跑！
boolean AsstStart(Pointer handle);
//爷不想跑了爷要自己玩
boolean AsstStop(Pointer handle);
/**
* 获取最后一次截图的内容
* (但是这个接口我就没成功用上过
* @param handle Maa实例
* @param buff 图片PNG格式编码内容
* @param buff_size byte[]的长度
* @return 图片长度
*/
long AsstGetImage(Pointer handle, byte[] buff, long buff_size);
//模拟点击
boolean AsstCtrlerClick(Pointer handle, int x, int y, boolean block);
//获取版本号
String AsstGetVersion();
//向maa注入日志
void AsstLog(String level, String message);
}
| MaaAssistantArknights/MaaAssistantArknights | src/Java/src/main/java/com/iguigui/maaj/easySample/MaaCore.java | 616 | //第一步，加载资源 | line_comment | zh-cn | package com.iguigui.maaj.easySample;
import com.sun.jna.Pointer;
import com.sun.jna.win32.StdCallLibrary;
//本质上是对C接口的抽象层
//请参考C接口 https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/master/include/AsstCaller.h
public interface MaaCore extends StdCallLibrary {
//回调接口定义
interface AsstApiCallback extends StdCallCallback {
void callback(int msg, String detail_json, String custom_arg);
}
//第一 <SUF>
boolean AsstLoadResource(String path);
//选一个你喜欢的create，搞不定回调就用普通create，又不是不能用
Pointer AsstCreate();
/**
* 带回调的实例创建
* @param callback 回调方法实例
* @param custom_arg 用户参数，塞什么进去回头就给你回调的时候返回什么，例如填入自己生成的实例ID，回调回来就可以用于查询是哪个实例的回调信息
* @return
*/
Pointer AsstCreateEx(AsstApiCallback callback, String custom_arg);
//销毁实例释放连接
void AsstDestroy(Pointer handle);
//连接安卓
boolean AsstConnect(Pointer handle, String adb, String host, String config);
//添加任务链
//参考集成文档 https://github.com/MaaAssistantArknights/MaaAssistantArknights/blob/master/docs/3.1-%E9%9B%86%E6%88%90%E6%96%87%E6%A1%A3.md
int AsstAppendTask(Pointer handle, String type, String params);
//运行时修改参数
boolean AsstSetTaskParams(Pointer handle, int taskId, String params);
//开跑！
boolean AsstStart(Pointer handle);
//爷不想跑了爷要自己玩
boolean AsstStop(Pointer handle);
/**
* 获取最后一次截图的内容
* (但是这个接口我就没成功用上过
* @param handle Maa实例
* @param buff 图片PNG格式编码内容
* @param buff_size byte[]的长度
* @return 图片长度
*/
long AsstGetImage(Pointer handle, byte[] buff, long buff_size);
//模拟点击
boolean AsstCtrlerClick(Pointer handle, int x, int y, boolean block);
//获取版本号
String AsstGetVersion();
//向maa注入日志
void AsstLog(String level, String message);
}
| false |
51092_0 | package cn.edu.hrbu.mall.aop;
import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
// 切面类
@Component
@Aspect // 声明当前类是一个切面类
public class Fbi {
// 切面类中的方法通常称为通知
// 前置通知
@Before("execution(* cn..Man.eat(*))") // 切入点表达式
public void beforeAdvice(){
System.out.println("执行前置通知，FBI正在调查");
}
// 后置通知,连接点之后执行
@After("within(cn..Man)")
public void afterAdvice(){
System.out.println("执行后置通知，FBI正在记录");
}
// 返回后通知，返回后通知是在目标方法执行之后（Return）执行的
@AfterReturning(pointcut = "execution(* cn..Man.call())", returning = "ret")
public void afterReturningAdvice(Object ret){
System.out.printf("执行返回后通知，FBI发现了，截获情报(%s)\t" , ret);
}
// 异常通知，异常通知是在目标方法执行过程中出现异常时执行的
@AfterThrowing(pointcut = "execution(* cn..Man.drive())", throwing = "exception")
public void afterThrowingAdvice(Exception exception){
System.out.println("执行异常通知，FBI发现了异常：" + exception.getMessage());
}
// 环绕通知，环绕通知是在目标方法执行之前和之后执行的，可以包裹连接点代码，是唯一可以控制目标方法（连接点）执行的通知
@Around("within(cn..Man)")
public Object aroundAdvice(ProceedingJoinPoint joinpoint) throws Throwable{
System.out.println("执行环绕通知(前半部分)，FBI正在调查");
Object[] args = joinpoint.getArgs();
Object ret = joinpoint.proceed();
System.out.println("执行环绕通知(后半部分)，FBI正在记录");
return ret;
}
}
| MadridWen/Study-MybatisAndSpring | mall/src/main/java/cn/edu/hrbu/mall/aop/Fbi.java | 516 | // 切面类
| line_comment | zh-cn | package cn.edu.hrbu.mall.aop;
import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
// 切面 <SUF>
@Component
@Aspect // 声明当前类是一个切面类
public class Fbi {
// 切面类中的方法通常称为通知
// 前置通知
@Before("execution(* cn..Man.eat(*))") // 切入点表达式
public void beforeAdvice(){
System.out.println("执行前置通知，FBI正在调查");
}
// 后置通知,连接点之后执行
@After("within(cn..Man)")
public void afterAdvice(){
System.out.println("执行后置通知，FBI正在记录");
}
// 返回后通知，返回后通知是在目标方法执行之后（Return）执行的
@AfterReturning(pointcut = "execution(* cn..Man.call())", returning = "ret")
public void afterReturningAdvice(Object ret){
System.out.printf("执行返回后通知，FBI发现了，截获情报(%s)\t" , ret);
}
// 异常通知，异常通知是在目标方法执行过程中出现异常时执行的
@AfterThrowing(pointcut = "execution(* cn..Man.drive())", throwing = "exception")
public void afterThrowingAdvice(Exception exception){
System.out.println("执行异常通知，FBI发现了异常：" + exception.getMessage());
}
// 环绕通知，环绕通知是在目标方法执行之前和之后执行的，可以包裹连接点代码，是唯一可以控制目标方法（连接点）执行的通知
@Around("within(cn..Man)")
public Object aroundAdvice(ProceedingJoinPoint joinpoint) throws Throwable{
System.out.println("执行环绕通知(前半部分)，FBI正在调查");
Object[] args = joinpoint.getArgs();
Object ret = joinpoint.proceed();
System.out.println("执行环绕通知(后半部分)，FBI正在记录");
return ret;
}
}
| false |
31537_25 | //package net.mafuyu33.mafishmod.networking.packet;
//
//import net.fabricmc.fabric.api.networking.v1.PacketSender;
//import net.mafuyu33.mafishmod.mixinhelper.BowDashMixinHelper;
//import net.mafuyu33.mafishmod.particle.ParticleStorage;
//import net.minecraft.entity.Entity;
//import net.minecraft.entity.LivingEntity;
//import net.minecraft.entity.player.PlayerEntity;
//import net.minecraft.network.PacketByteBuf;
//import net.minecraft.server.MinecraftServer;
//import net.minecraft.server.network.ServerPlayNetworkHandler;
//import net.minecraft.server.network.ServerPlayerEntity;
//import net.minecraft.util.math.Box;
//import net.minecraft.util.math.Vec3d;
//
//import java.util.List;
//
//public class ParticleColorC2SPacket {
//
// public static void receive(MinecraftServer server, ServerPlayerEntity player, ServerPlayNetworkHandler handler,
// PacketByteBuf buf, PacketSender responseSender) {
// int id = buf.readInt();
//// Vec3d pos = ParticleStorage.getOrCreateForWorld().getUUIDByPosition();
// if(pos!=null) {
// //想办法让碰到这个粒子的生物（除了玩家被击退+受伤）
// // 获取范围内的所有生物
// Box box1 = new Box(pos.x - 1.0, pos.y - 1.0, pos.z - 1.0, pos.x + 1.0, pos.y + 1.0, pos.z + 1.0);
// Box box2 = new Box(pos.x - 0.1, pos.y - 0.1, pos.z - 0.1, pos.x + 0.1, pos.y + 0.1, pos.z + 0.1);
// List<Entity> entities = player.getWorld().getOtherEntities(null, box1, entity -> entity instanceof LivingEntity && !(entity instanceof PlayerEntity));
// // 遍历每个生物并检查碰撞
// for (Entity entity : entities) {
// if (entity.getBoundingBox().intersects(box2)) {
// System.out.println("碰撞!");
// // 碰到生物时，除了玩家之外，对其进行击退和受伤
// if (entity instanceof LivingEntity livingEntity) {
// System.out.println("造成伤害！");
// Vec3d knockBackVec = new Vec3d(entity.getX() - pos.x, entity.getY() - pos.y, entity.getZ() - pos.z).normalize().multiply(-1.0); // 计算击退向量
// livingEntity.takeKnockback(1.0f, knockBackVec.x, knockBackVec.z); // 进行击退
// livingEntity.damage(player.getWorld().getDamageSources().magic(), 1.0f); // 造成伤害
// }
// }
// }
// }
// }
//}
| Mafuyu33/mafishmod | src/main/java/net/mafuyu33/mafishmod/networking/packet/C2S/ParticleColorC2SPacket.java | 776 | // // 遍历每个生物并检查碰撞 | line_comment | zh-cn | //package net.mafuyu33.mafishmod.networking.packet;
//
//import net.fabricmc.fabric.api.networking.v1.PacketSender;
//import net.mafuyu33.mafishmod.mixinhelper.BowDashMixinHelper;
//import net.mafuyu33.mafishmod.particle.ParticleStorage;
//import net.minecraft.entity.Entity;
//import net.minecraft.entity.LivingEntity;
//import net.minecraft.entity.player.PlayerEntity;
//import net.minecraft.network.PacketByteBuf;
//import net.minecraft.server.MinecraftServer;
//import net.minecraft.server.network.ServerPlayNetworkHandler;
//import net.minecraft.server.network.ServerPlayerEntity;
//import net.minecraft.util.math.Box;
//import net.minecraft.util.math.Vec3d;
//
//import java.util.List;
//
//public class ParticleColorC2SPacket {
//
// public static void receive(MinecraftServer server, ServerPlayerEntity player, ServerPlayNetworkHandler handler,
// PacketByteBuf buf, PacketSender responseSender) {
// int id = buf.readInt();
//// Vec3d pos = ParticleStorage.getOrCreateForWorld().getUUIDByPosition();
// if(pos!=null) {
// //想办法让碰到这个粒子的生物（除了玩家被击退+受伤）
// // 获取范围内的所有生物
// Box box1 = new Box(pos.x - 1.0, pos.y - 1.0, pos.z - 1.0, pos.x + 1.0, pos.y + 1.0, pos.z + 1.0);
// Box box2 = new Box(pos.x - 0.1, pos.y - 0.1, pos.z - 0.1, pos.x + 0.1, pos.y + 0.1, pos.z + 0.1);
// List<Entity> entities = player.getWorld().getOtherEntities(null, box1, entity -> entity instanceof LivingEntity && !(entity instanceof PlayerEntity));
// // 遍历 <SUF>
// for (Entity entity : entities) {
// if (entity.getBoundingBox().intersects(box2)) {
// System.out.println("碰撞!");
// // 碰到生物时，除了玩家之外，对其进行击退和受伤
// if (entity instanceof LivingEntity livingEntity) {
// System.out.println("造成伤害！");
// Vec3d knockBackVec = new Vec3d(entity.getX() - pos.x, entity.getY() - pos.y, entity.getZ() - pos.z).normalize().multiply(-1.0); // 计算击退向量
// livingEntity.takeKnockback(1.0f, knockBackVec.x, knockBackVec.z); // 进行击退
// livingEntity.damage(player.getWorld().getDamageSources().magic(), 1.0f); // 造成伤害
// }
// }
// }
// }
// }
//}
| false |
25351_4 | package solorSystem;
/**
*
* @ClassName : SolarFrame.java
* @author : Magneto_Wang
* @date 2018年6月26日 下午11:16:37
* @Description TODO
*
*/
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
public class SolarFrame extends MyFrame {
private Image iBuffer;
private Graphics gBuffer;
SolarFrame(String s) {
super(s);
}
private static final long serialVersionUID = 1L;
Image bg = GameUtil.getImage("Picture\\Background_image.jpg");// 背景图片
Star Sun = new Star("Picture\\sun.jpg", Constant.FRAME_WIDETH / 2, Constant.FRAME_HIGHTH / 2);
Planet mercury = new Planet(Sun, "Picture\\Mercury.jpg", 110, 50, 0.3);// 水星
Planet venus = new Planet(Sun, "Picture\\Venus.jpg", 150, 90, 0.4);// 金星
Planet earth = new Planet(Sun, "Picture\\earth.jpg", 190, 130, 0.1);// 地球
Planet mars = new Planet(Sun, "Picture\\Mars.jpg", 230, 170, 0.3);// 火星
Planet jupiter = new Planet(Sun, "Picture\\Jupiter.jpg", 270, 210, 0.4);// 木星
Planet saturn = new Planet(Sun, "Picture\\Saturn.jpg", 310, 250, 0.3);// 土星
Planet uranus = new Planet(Sun, "Picture\\Uranus.jpg", 340, 290, 0.2);// 天王星
Planet neptune = new Planet(Sun, "Picture\\Neptune.jpg", 380,330, 0.1);// 海王星
Planet moon = new Planet(earth, "Picture\\moon.jpg", 30, 20, 0.2, true);// 月球
public void paint(Graphics g) {
Color c = g.getColor();
g.drawImage(bg,0,0,null);
Sun.draw(g);
mercury.draw(g);
venus.draw(g);
earth.draw(g);
mars.draw(g);
jupiter.draw(g);
saturn.draw(g);
uranus.draw(g);
neptune.draw(g);
moon.draw(g);
this.setVisible(true);
g.setColor(c);
}
//JAVA双缓冲 ，防止屏幕闪烁
public void update(Graphics scr)
{
if(iBuffer==null)
{
iBuffer=createImage(this.getSize().width,this.getSize().height);
gBuffer=iBuffer.getGraphics();
}
gBuffer.setColor(getBackground());
gBuffer.fillRect(0,0,this.getSize().width,this.getSize().height);
paint(gBuffer);
scr.drawImage(iBuffer,0,0,this);
}
public static void main(String[] args) {
new SolarFrame("太阳系模型").launchFrame();
}
}
| MagnetoWang/ComputerGraphics | src/main/java/solorSystem/SolarFrame.java | 832 | //JAVA双缓冲 ，防止屏幕闪烁 | line_comment | zh-cn | package solorSystem;
/**
*
* @ClassName : SolarFrame.java
* @author : Magneto_Wang
* @date 2018年6月26日 下午11:16:37
* @Description TODO
*
*/
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
public class SolarFrame extends MyFrame {
private Image iBuffer;
private Graphics gBuffer;
SolarFrame(String s) {
super(s);
}
private static final long serialVersionUID = 1L;
Image bg = GameUtil.getImage("Picture\\Background_image.jpg");// 背景图片
Star Sun = new Star("Picture\\sun.jpg", Constant.FRAME_WIDETH / 2, Constant.FRAME_HIGHTH / 2);
Planet mercury = new Planet(Sun, "Picture\\Mercury.jpg", 110, 50, 0.3);// 水星
Planet venus = new Planet(Sun, "Picture\\Venus.jpg", 150, 90, 0.4);// 金星
Planet earth = new Planet(Sun, "Picture\\earth.jpg", 190, 130, 0.1);// 地球
Planet mars = new Planet(Sun, "Picture\\Mars.jpg", 230, 170, 0.3);// 火星
Planet jupiter = new Planet(Sun, "Picture\\Jupiter.jpg", 270, 210, 0.4);// 木星
Planet saturn = new Planet(Sun, "Picture\\Saturn.jpg", 310, 250, 0.3);// 土星
Planet uranus = new Planet(Sun, "Picture\\Uranus.jpg", 340, 290, 0.2);// 天王星
Planet neptune = new Planet(Sun, "Picture\\Neptune.jpg", 380,330, 0.1);// 海王星
Planet moon = new Planet(earth, "Picture\\moon.jpg", 30, 20, 0.2, true);// 月球
public void paint(Graphics g) {
Color c = g.getColor();
g.drawImage(bg,0,0,null);
Sun.draw(g);
mercury.draw(g);
venus.draw(g);
earth.draw(g);
mars.draw(g);
jupiter.draw(g);
saturn.draw(g);
uranus.draw(g);
neptune.draw(g);
moon.draw(g);
this.setVisible(true);
g.setColor(c);
}
//JA <SUF>
public void update(Graphics scr)
{
if(iBuffer==null)
{
iBuffer=createImage(this.getSize().width,this.getSize().height);
gBuffer=iBuffer.getGraphics();
}
gBuffer.setColor(getBackground());
gBuffer.fillRect(0,0,this.getSize().width,this.getSize().height);
paint(gBuffer);
scr.drawImage(iBuffer,0,0,this);
}
public static void main(String[] args) {
new SolarFrame("太阳系模型").launchFrame();
}
}
| true |
58217_12 | //请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi,
//numberOfUnitsPerBoxi] ：
//
//
// numberOfBoxesi 是类型 i 的箱子的数量。
// numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。
//
//
// 整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。
//
// 返回卡车可以装载 单元 的 最大 总数。
//
//
//
// 示例 1：
//
//
//输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
//输出：8
//解释：箱子的情况如下：
//- 1 个第一类的箱子，里面含 3 个单元。
//- 2 个第二类的箱子，每个里面含 2 个单元。
//- 3 个第三类的箱子，每个里面含 1 个单元。
//可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
//单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8
//
// 示例 2：
//
//
//输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
//输出：91
//
//
//
//
// 提示：
//
//
// 1 <= boxTypes.length <= 1000
// 1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000
// 1 <= truckSize <= 10⁶
//
//
// Related Topics 贪心 数组 排序 👍 75 👎 0
package leetcode.editor.cn;
import java.util.Arrays;
public class MaximumUnitsOnATruck1710 {
public static void main(String[] args) {
Solution solution = new MaximumUnitsOnATruck1710().new Solution();
System.out.println(solution.maximumUnits(new int[][]{{1, 3}, {2, 2}, {3, 1}}, 4));
System.out.println(solution.maximumUnits(new int[][]{{5, 10}, {2, 5}, {4, 7}, {3, 9}}, 10));
}
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public int maximumUnits(int[][] boxTypes, int truckSize) {
// 贪心
// 先装价值大的 那么所以就要先把价值大的放进去
Arrays.sort(boxTypes, (a, b) -> b[1] - a[1]);
int res = 0;
for (int[] boxType : boxTypes) {
if (truckSize >= boxType[0]) {
truckSize -= boxType[0];
res += boxType[0] * boxType[1];
} else {
// 这个时候就小于了 就只能加上 truckSize 个了
res += truckSize * boxType[1];
break;
}
}
return res;
}
public int maximumUnitsWithDp(int[][] boxTypes, int truckSize) {
int[] dp = new int[truckSize + 1];
for (int[] boxType : boxTypes) {
for (int i = truckSize; i >= 0; i--) {
// 尝试装进去
// 尝试每个大小的盒子都装进去
for (int j = 1; j <= boxType[0]; j++) {
if (i >= j) {
dp[i] = Math.max(dp[i], dp[i - j] + j * boxType[1]);
} else {
dp[i] = Math.max(dp[i], dp[0] + i * boxType[1]);
break;
}
}
}
}
return dp[truckSize];
}
}
//leetcode submit region end(Prohibit modification and deletion)
} | MajexH/leetcode | java/src/leetcode/editor/cn/MaximumUnitsOnATruck1710.java | 1,024 | //- 3 个第三类的箱子，每个里面含 1 个单元。 | line_comment | zh-cn | //请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi,
//numberOfUnitsPerBoxi] ：
//
//
// numberOfBoxesi 是类型 i 的箱子的数量。
// numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。
//
//
// 整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。
//
// 返回卡车可以装载 单元 的 最大 总数。
//
//
//
// 示例 1：
//
//
//输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
//输出：8
//解释：箱子的情况如下：
//- 1 个第一类的箱子，里面含 3 个单元。
//- 2 个第二类的箱子，每个里面含 2 个单元。
//- <SUF>
//可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
//单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8
//
// 示例 2：
//
//
//输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
//输出：91
//
//
//
//
// 提示：
//
//
// 1 <= boxTypes.length <= 1000
// 1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000
// 1 <= truckSize <= 10⁶
//
//
// Related Topics 贪心 数组 排序 👍 75 👎 0
package leetcode.editor.cn;
import java.util.Arrays;
public class MaximumUnitsOnATruck1710 {
public static void main(String[] args) {
Solution solution = new MaximumUnitsOnATruck1710().new Solution();
System.out.println(solution.maximumUnits(new int[][]{{1, 3}, {2, 2}, {3, 1}}, 4));
System.out.println(solution.maximumUnits(new int[][]{{5, 10}, {2, 5}, {4, 7}, {3, 9}}, 10));
}
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public int maximumUnits(int[][] boxTypes, int truckSize) {
// 贪心
// 先装价值大的 那么所以就要先把价值大的放进去
Arrays.sort(boxTypes, (a, b) -> b[1] - a[1]);
int res = 0;
for (int[] boxType : boxTypes) {
if (truckSize >= boxType[0]) {
truckSize -= boxType[0];
res += boxType[0] * boxType[1];
} else {
// 这个时候就小于了 就只能加上 truckSize 个了
res += truckSize * boxType[1];
break;
}
}
return res;
}
public int maximumUnitsWithDp(int[][] boxTypes, int truckSize) {
int[] dp = new int[truckSize + 1];
for (int[] boxType : boxTypes) {
for (int i = truckSize; i >= 0; i--) {
// 尝试装进去
// 尝试每个大小的盒子都装进去
for (int j = 1; j <= boxType[0]; j++) {
if (i >= j) {
dp[i] = Math.max(dp[i], dp[i - j] + j * boxType[1]);
} else {
dp[i] = Math.max(dp[i], dp[0] + i * boxType[1]);
break;
}
}
}
}
return dp[truckSize];
}
}
//leetcode submit region end(Prohibit modification and deletion)
} | true |
57370_9 | // 1.2.11 根据Date的API实现一个SmartDate类型，在日期非法时抛出一个异常。
//
// 1.2.12 为SmartDate添加一个方法dayOfTheWeek()，为日期中每周的日返回 Monday、Tuesday、Wednesday、Thursday、Friday、Saturday 或 Sunday 中的适当值。你可以假定时间是21世纪。
// 1.2.19 字符串解析。为你在练习1.2.13中实现的Date和Transaction类型编写能够解析字符串数据的构造函数。它接受一个String参数指定的初始值，格式如表1.2.20所示：
// Date 由斜杠分隔的整数 5/22/1939
import edu.princeton.cs.algs4.StdOut;
public class Ex_1_2_11 {
// static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。
// 而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
private static final int[] DAYS = new int[] {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
private final int month;
private final int day;
private final int year;
public Ex_1_2_11(int m, int d, int y) {
if (!isVaild(m, d, y))
throw new IllegalArgumentException("Invalid date");
month = m;
day = d;
year = y;
}
// @param date String 由斜杠分隔的整数 格式为5/22/1939
public Ex_1_2_11(String date) {
String[] strings = date.split("/");
int[] ints = new int[strings.length];
for (int i = 0; i < ints.length; i++)
ints[i] = Integer.parseInt(strings[i]);
if (!isVaild(ints[0], ints[1], ints[2]))
throw new IllegalArgumentException("Invalid date");
month = ints[0];
day = ints[1];
year = ints[2];
}
private static boolean isVaild(int m, int d, int y) {
if (m > 12 || m <= 0)
return false;
if (d > DAYS[m])
return false;
if (m == 2 && d == 29 && !isLeapYear(y))
return false;
return true;
}
// 闰年是公历中的名词，能被4整除但不能被100整除，或能被400整除的年份即为闰年。
private static boolean isLeapYear(int y) {
if (y % 400 == 0) return true;
if (y % 100 == 0) return false;
return y % 4 == 0;
}
// 蔡勒（Zeller）公式，（蔡勒公式只适合于1582年（中国明朝万历十年）10月15日之后的情形）
// w：星期； w对7取模得：0-星期日，1-星期一，2-星期二，3-星期三，4-星期四，5-星期五，6-星期六
// c：世纪（年份前两位数）
// y：年（后两位数）
// m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13月1日来计算）
// d：日
// [ ]代表取整，即只要整数部分。
// w=(y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1)%7
private static String dayOfTheweek(int m, int d, int y) {
if (!isVaild(m, d, y))
throw new IllegalArgumentException("Invalid date");
if (y < 1582)
throw new IllegalArgumentException("Unable to calculate");
if (y == 1582 && m < 10)
throw new IllegalArgumentException("Unable to calculate");
if (y == 1582 && m == 10 && d < 15)
throw new IllegalArgumentException("Unable to calculate");
if (m <= 2) {
m += 12;
y--;
}
int c = y / 100;
y = y % 100;
int w = (y + (y / 4) + (c / 4) - 2 * c + (26 * (m + 1) / 10) + d - 1) % 7;
switch (w) {
case 0:
return "Sunday";
case 1:
return "Monday";
case 2:
return "Tuesday";
case 3:
return "Wednesday";
case 4:
return "Thursday";
case 5:
return "Friday";
case 6:
return "Saturday";
default:
return "Sunday";
}
}
public int day() {
return day;
}
public int month() {
return month;
}
public int year() {
return year;
}
public String toString() {
return month() + "/" + day() + "/" + year();
}
public static void main(String[] args) {
// http://www.cnblogs.com/dolphin0520/p/3799052.html
// “static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。
// 而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
StdOut.println(Ex_1_2_11.isVaild(8, 40, 2017));
StdOut.println(Ex_1_2_11.dayOfTheweek(8, 16, 2017));
StdOut.println(Ex_1_2_11.dayOfTheweek(7, 16, 2017));
StdOut.println(Ex_1_2_11.dayOfTheweek(11, 22, 1992));
// StdOut.println(Ex_1_2_11.dayOfTheweek(10, 10, 1582));
Ex_1_2_11 dateString = new Ex_1_2_11("5/22/1939");
StdOut.println(dateString);
Ex_1_2_11 date1 = new Ex_1_2_11(8, 14, 2017);
StdOut.println(date1);
Ex_1_2_11 date2 = new Ex_1_2_11(8, 40, 2017);
StdOut.println(date2);
}
} | MajimaGoro/Algs4 | Chapter_01/Ex_1_2_11.java | 1,786 | // w：星期； w对7取模得：0-星期日，1-星期一，2-星期二，3-星期三，4-星期四，5-星期五，6-星期六 | line_comment | zh-cn | // 1.2.11 根据Date的API实现一个SmartDate类型，在日期非法时抛出一个异常。
//
// 1.2.12 为SmartDate添加一个方法dayOfTheWeek()，为日期中每周的日返回 Monday、Tuesday、Wednesday、Thursday、Friday、Saturday 或 Sunday 中的适当值。你可以假定时间是21世纪。
// 1.2.19 字符串解析。为你在练习1.2.13中实现的Date和Transaction类型编写能够解析字符串数据的构造函数。它接受一个String参数指定的初始值，格式如表1.2.20所示：
// Date 由斜杠分隔的整数 5/22/1939
import edu.princeton.cs.algs4.StdOut;
public class Ex_1_2_11 {
// static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。
// 而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
private static final int[] DAYS = new int[] {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
private final int month;
private final int day;
private final int year;
public Ex_1_2_11(int m, int d, int y) {
if (!isVaild(m, d, y))
throw new IllegalArgumentException("Invalid date");
month = m;
day = d;
year = y;
}
// @param date String 由斜杠分隔的整数 格式为5/22/1939
public Ex_1_2_11(String date) {
String[] strings = date.split("/");
int[] ints = new int[strings.length];
for (int i = 0; i < ints.length; i++)
ints[i] = Integer.parseInt(strings[i]);
if (!isVaild(ints[0], ints[1], ints[2]))
throw new IllegalArgumentException("Invalid date");
month = ints[0];
day = ints[1];
year = ints[2];
}
private static boolean isVaild(int m, int d, int y) {
if (m > 12 || m <= 0)
return false;
if (d > DAYS[m])
return false;
if (m == 2 && d == 29 && !isLeapYear(y))
return false;
return true;
}
// 闰年是公历中的名词，能被4整除但不能被100整除，或能被400整除的年份即为闰年。
private static boolean isLeapYear(int y) {
if (y % 400 == 0) return true;
if (y % 100 == 0) return false;
return y % 4 == 0;
}
// 蔡勒（Zeller）公式，（蔡勒公式只适合于1582年（中国明朝万历十年）10月15日之后的情形）
// w： <SUF>
// c：世纪（年份前两位数）
// y：年（后两位数）
// m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13月1日来计算）
// d：日
// [ ]代表取整，即只要整数部分。
// w=(y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1)%7
private static String dayOfTheweek(int m, int d, int y) {
if (!isVaild(m, d, y))
throw new IllegalArgumentException("Invalid date");
if (y < 1582)
throw new IllegalArgumentException("Unable to calculate");
if (y == 1582 && m < 10)
throw new IllegalArgumentException("Unable to calculate");
if (y == 1582 && m == 10 && d < 15)
throw new IllegalArgumentException("Unable to calculate");
if (m <= 2) {
m += 12;
y--;
}
int c = y / 100;
y = y % 100;
int w = (y + (y / 4) + (c / 4) - 2 * c + (26 * (m + 1) / 10) + d - 1) % 7;
switch (w) {
case 0:
return "Sunday";
case 1:
return "Monday";
case 2:
return "Tuesday";
case 3:
return "Wednesday";
case 4:
return "Thursday";
case 5:
return "Friday";
case 6:
return "Saturday";
default:
return "Sunday";
}
}
public int day() {
return day;
}
public int month() {
return month;
}
public int year() {
return year;
}
public String toString() {
return month() + "/" + day() + "/" + year();
}
public static void main(String[] args) {
// http://www.cnblogs.com/dolphin0520/p/3799052.html
// “static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。
// 而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”
StdOut.println(Ex_1_2_11.isVaild(8, 40, 2017));
StdOut.println(Ex_1_2_11.dayOfTheweek(8, 16, 2017));
StdOut.println(Ex_1_2_11.dayOfTheweek(7, 16, 2017));
StdOut.println(Ex_1_2_11.dayOfTheweek(11, 22, 1992));
// StdOut.println(Ex_1_2_11.dayOfTheweek(10, 10, 1582));
Ex_1_2_11 dateString = new Ex_1_2_11("5/22/1939");
StdOut.println(dateString);
Ex_1_2_11 date1 = new Ex_1_2_11(8, 14, 2017);
StdOut.println(date1);
Ex_1_2_11 date2 = new Ex_1_2_11(8, 40, 2017);
StdOut.println(date2);
}
} | true |
28109_5 | /*
* Copyright (C) 2016 huanghaibin_dev <huanghaibin_dev@163.com>
* WebSite https://github.com/MiracleTimes-Dev
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.haibin.calendarview;
import android.content.Context;
import android.graphics.Canvas;
import android.view.View;
/**
* 月视图基础控件,可自由继承实现
* Created by huanghaibin on 2017/11/15.
*/
public abstract class MonthView extends BaseMonthView {
public MonthView(Context context) {
super(context);
}
@Override
protected void onDraw(Canvas canvas) {
if (mLineCount == 0)
return;
mItemWidth = (getWidth() - 2 * mDelegate.getCalendarPadding()) / 7;
onPreviewHook();
int count = mLineCount * 7;
int d = 0;
for (int i = 0; i < mLineCount; i++) {
for (int j = 0; j < 7; j++) {
Calendar calendar = mItems.get(d);
if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_ONLY_CURRENT_MONTH) {
if (d > mItems.size() - mNextDiff) {
return;
}
if (!calendar.isCurrentMonth()) {
++d;
continue;
}
} else if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_FIT_MONTH) {
if (d >= count) {
return;
}
}
draw(canvas, calendar, i, j, d);
++d;
}
}
}
/**
* 开始绘制
*
* @param canvas canvas
* @param calendar 对应日历
* @param i i
* @param j j
* @param d d
*/
private void draw(Canvas canvas, Calendar calendar, int i, int j, int d) {
int x = j * mItemWidth + mDelegate.getCalendarPadding();
int y = i * mItemHeight;
onLoopStart(x, y);
boolean isSelected = d == mCurrentItem;
boolean hasScheme = calendar.hasScheme();
if (hasScheme) {
//标记的日子
boolean isDrawSelected = false;//是否继续绘制选中的onDrawScheme
if (isSelected) {
isDrawSelected = onDrawSelected(canvas, calendar, x, y, true);
}
if (isDrawSelected || !isSelected) {
//将画笔设置为标记颜色
mSchemePaint.setColor(calendar.getSchemeColor() != 0 ? calendar.getSchemeColor() : mDelegate.getSchemeThemeColor());
onDrawScheme(canvas, calendar, x, y);
}
} else {
if (isSelected) {
onDrawSelected(canvas, calendar, x, y, false);
}
}
onDrawText(canvas, calendar, x, y, hasScheme, isSelected);
}
@Override
public void onClick(View v) {
if (!isClick) {
return;
}
Calendar calendar = getIndex();
if (calendar == null) {
return;
}
if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_ONLY_CURRENT_MONTH &&
!calendar.isCurrentMonth()) {
return;
}
if (onCalendarIntercept(calendar)) {
mDelegate.mCalendarInterceptListener.onCalendarInterceptClick(calendar, true);
return;
}
if (!isInRange(calendar)) {
if (mDelegate.mCalendarSelectListener != null) {
mDelegate.mCalendarSelectListener.onCalendarOutOfRange(calendar);
}
return;
}
mCurrentItem = mItems.indexOf(calendar);
if (!calendar.isCurrentMonth() && mMonthViewPager != null) {
int cur = mMonthViewPager.getCurrentItem();
int position = mCurrentItem < 7 ? cur - 1 : cur + 1;
mMonthViewPager.setCurrentItem(position);
}
if (mDelegate.mInnerListener != null) {
mDelegate.mInnerListener.onMonthDateSelected(calendar, true);
}
if (mParentLayout != null) {
if (calendar.isCurrentMonth()) {
mParentLayout.updateSelectPosition(mItems.indexOf(calendar));
} else {
mParentLayout.updateSelectWeek(CalendarUtil.getWeekFromDayInMonth(calendar, mDelegate.getWeekStart()));
}
}
if (mDelegate.mCalendarSelectListener != null) {
mDelegate.mCalendarSelectListener.onCalendarSelect(calendar, true);
}
}
@Override
public boolean onLongClick(View v) {
if (mDelegate.mCalendarLongClickListener == null)
return false;
if (!isClick) {
return false;
}
Calendar calendar = getIndex();
if (calendar == null) {
return false;
}
if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_ONLY_CURRENT_MONTH &&
!calendar.isCurrentMonth()) {
return false;
}
if (onCalendarIntercept(calendar)) {
mDelegate.mCalendarInterceptListener.onCalendarInterceptClick(calendar, true);
return false;
}
boolean isCalendarInRange = isInRange(calendar);
if (!isCalendarInRange) {
if (mDelegate.mCalendarLongClickListener != null) {
mDelegate.mCalendarLongClickListener.onCalendarLongClickOutOfRange(calendar);
}
return true;
}
if (mDelegate.isPreventLongPressedSelected()) {
if (mDelegate.mCalendarLongClickListener != null) {
mDelegate.mCalendarLongClickListener.onCalendarLongClick(calendar);
}
return true;
}
mCurrentItem = mItems.indexOf(calendar);
if (!calendar.isCurrentMonth() && mMonthViewPager != null) {
int cur = mMonthViewPager.getCurrentItem();
int position = mCurrentItem < 7 ? cur - 1 : cur + 1;
mMonthViewPager.setCurrentItem(position);
}
if (mDelegate.mInnerListener != null) {
mDelegate.mInnerListener.onMonthDateSelected(calendar, true);
}
if (mParentLayout != null) {
if (calendar.isCurrentMonth()) {
mParentLayout.updateSelectPosition(mItems.indexOf(calendar));
} else {
mParentLayout.updateSelectWeek(CalendarUtil.getWeekFromDayInMonth(calendar, mDelegate.getWeekStart()));
}
}
if (mDelegate.mCalendarSelectListener != null) {
mDelegate.mCalendarSelectListener.onCalendarSelect(calendar, true);
}
if (mDelegate.mCalendarLongClickListener != null) {
mDelegate.mCalendarLongClickListener.onCalendarLongClick(calendar);
}
invalidate();
return true;
}
/**
* 绘制选中的日期
*
* @param canvas canvas
* @param calendar 日历日历calendar
* @param x 日历Card x起点坐标
* @param y 日历Card y起点坐标
* @param hasScheme hasScheme 非标记的日期
* @return 是否绘制onDrawScheme，true or false
*/
protected abstract boolean onDrawSelected(Canvas canvas, Calendar calendar, int x, int y, boolean hasScheme);
/**
* 绘制标记的日期,这里可以是背景色，标记色什么的
*
* @param canvas canvas
* @param calendar 日历calendar
* @param x 日历Card x起点坐标
* @param y 日历Card y起点坐标
*/
protected abstract void onDrawScheme(Canvas canvas, Calendar calendar, int x, int y);
/**
* 绘制日历文本
*
* @param canvas canvas
* @param calendar 日历calendar
* @param x 日历Card x起点坐标
* @param y 日历Card y起点坐标
* @param hasScheme 是否是标记的日期
* @param isSelected 是否选中
*/
protected abstract void onDrawText(Canvas canvas, Calendar calendar, int x, int y, boolean hasScheme, boolean isSelected);
}
| MalitsPlus/ShizuruNotes | calendarview/src/main/java/com/haibin/calendarview/MonthView.java | 2,006 | //将画笔设置为标记颜色 | line_comment | zh-cn | /*
* Copyright (C) 2016 huanghaibin_dev <huanghaibin_dev@163.com>
* WebSite https://github.com/MiracleTimes-Dev
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.haibin.calendarview;
import android.content.Context;
import android.graphics.Canvas;
import android.view.View;
/**
* 月视图基础控件,可自由继承实现
* Created by huanghaibin on 2017/11/15.
*/
public abstract class MonthView extends BaseMonthView {
public MonthView(Context context) {
super(context);
}
@Override
protected void onDraw(Canvas canvas) {
if (mLineCount == 0)
return;
mItemWidth = (getWidth() - 2 * mDelegate.getCalendarPadding()) / 7;
onPreviewHook();
int count = mLineCount * 7;
int d = 0;
for (int i = 0; i < mLineCount; i++) {
for (int j = 0; j < 7; j++) {
Calendar calendar = mItems.get(d);
if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_ONLY_CURRENT_MONTH) {
if (d > mItems.size() - mNextDiff) {
return;
}
if (!calendar.isCurrentMonth()) {
++d;
continue;
}
} else if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_FIT_MONTH) {
if (d >= count) {
return;
}
}
draw(canvas, calendar, i, j, d);
++d;
}
}
}
/**
* 开始绘制
*
* @param canvas canvas
* @param calendar 对应日历
* @param i i
* @param j j
* @param d d
*/
private void draw(Canvas canvas, Calendar calendar, int i, int j, int d) {
int x = j * mItemWidth + mDelegate.getCalendarPadding();
int y = i * mItemHeight;
onLoopStart(x, y);
boolean isSelected = d == mCurrentItem;
boolean hasScheme = calendar.hasScheme();
if (hasScheme) {
//标记的日子
boolean isDrawSelected = false;//是否继续绘制选中的onDrawScheme
if (isSelected) {
isDrawSelected = onDrawSelected(canvas, calendar, x, y, true);
}
if (isDrawSelected || !isSelected) {
//将画 <SUF>
mSchemePaint.setColor(calendar.getSchemeColor() != 0 ? calendar.getSchemeColor() : mDelegate.getSchemeThemeColor());
onDrawScheme(canvas, calendar, x, y);
}
} else {
if (isSelected) {
onDrawSelected(canvas, calendar, x, y, false);
}
}
onDrawText(canvas, calendar, x, y, hasScheme, isSelected);
}
@Override
public void onClick(View v) {
if (!isClick) {
return;
}
Calendar calendar = getIndex();
if (calendar == null) {
return;
}
if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_ONLY_CURRENT_MONTH &&
!calendar.isCurrentMonth()) {
return;
}
if (onCalendarIntercept(calendar)) {
mDelegate.mCalendarInterceptListener.onCalendarInterceptClick(calendar, true);
return;
}
if (!isInRange(calendar)) {
if (mDelegate.mCalendarSelectListener != null) {
mDelegate.mCalendarSelectListener.onCalendarOutOfRange(calendar);
}
return;
}
mCurrentItem = mItems.indexOf(calendar);
if (!calendar.isCurrentMonth() && mMonthViewPager != null) {
int cur = mMonthViewPager.getCurrentItem();
int position = mCurrentItem < 7 ? cur - 1 : cur + 1;
mMonthViewPager.setCurrentItem(position);
}
if (mDelegate.mInnerListener != null) {
mDelegate.mInnerListener.onMonthDateSelected(calendar, true);
}
if (mParentLayout != null) {
if (calendar.isCurrentMonth()) {
mParentLayout.updateSelectPosition(mItems.indexOf(calendar));
} else {
mParentLayout.updateSelectWeek(CalendarUtil.getWeekFromDayInMonth(calendar, mDelegate.getWeekStart()));
}
}
if (mDelegate.mCalendarSelectListener != null) {
mDelegate.mCalendarSelectListener.onCalendarSelect(calendar, true);
}
}
@Override
public boolean onLongClick(View v) {
if (mDelegate.mCalendarLongClickListener == null)
return false;
if (!isClick) {
return false;
}
Calendar calendar = getIndex();
if (calendar == null) {
return false;
}
if (mDelegate.getMonthViewShowMode() == CalendarViewDelegate.MODE_ONLY_CURRENT_MONTH &&
!calendar.isCurrentMonth()) {
return false;
}
if (onCalendarIntercept(calendar)) {
mDelegate.mCalendarInterceptListener.onCalendarInterceptClick(calendar, true);
return false;
}
boolean isCalendarInRange = isInRange(calendar);
if (!isCalendarInRange) {
if (mDelegate.mCalendarLongClickListener != null) {
mDelegate.mCalendarLongClickListener.onCalendarLongClickOutOfRange(calendar);
}
return true;
}
if (mDelegate.isPreventLongPressedSelected()) {
if (mDelegate.mCalendarLongClickListener != null) {
mDelegate.mCalendarLongClickListener.onCalendarLongClick(calendar);
}
return true;
}
mCurrentItem = mItems.indexOf(calendar);
if (!calendar.isCurrentMonth() && mMonthViewPager != null) {
int cur = mMonthViewPager.getCurrentItem();
int position = mCurrentItem < 7 ? cur - 1 : cur + 1;
mMonthViewPager.setCurrentItem(position);
}
if (mDelegate.mInnerListener != null) {
mDelegate.mInnerListener.onMonthDateSelected(calendar, true);
}
if (mParentLayout != null) {
if (calendar.isCurrentMonth()) {
mParentLayout.updateSelectPosition(mItems.indexOf(calendar));
} else {
mParentLayout.updateSelectWeek(CalendarUtil.getWeekFromDayInMonth(calendar, mDelegate.getWeekStart()));
}
}
if (mDelegate.mCalendarSelectListener != null) {
mDelegate.mCalendarSelectListener.onCalendarSelect(calendar, true);
}
if (mDelegate.mCalendarLongClickListener != null) {
mDelegate.mCalendarLongClickListener.onCalendarLongClick(calendar);
}
invalidate();
return true;
}
/**
* 绘制选中的日期
*
* @param canvas canvas
* @param calendar 日历日历calendar
* @param x 日历Card x起点坐标
* @param y 日历Card y起点坐标
* @param hasScheme hasScheme 非标记的日期
* @return 是否绘制onDrawScheme，true or false
*/
protected abstract boolean onDrawSelected(Canvas canvas, Calendar calendar, int x, int y, boolean hasScheme);
/**
* 绘制标记的日期,这里可以是背景色，标记色什么的
*
* @param canvas canvas
* @param calendar 日历calendar
* @param x 日历Card x起点坐标
* @param y 日历Card y起点坐标
*/
protected abstract void onDrawScheme(Canvas canvas, Calendar calendar, int x, int y);
/**
* 绘制日历文本
*
* @param canvas canvas
* @param calendar 日历calendar
* @param x 日历Card x起点坐标
* @param y 日历Card y起点坐标
* @param hasScheme 是否是标记的日期
* @param isSelected 是否选中
*/
protected abstract void onDrawText(Canvas canvas, Calendar calendar, int x, int y, boolean hasScheme, boolean isSelected);
}
| true |
7973_9 | package com.antony.mail;
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
public class SendMail {
public static void main(String[] args) {
try {
Properties p = new Properties();
p.put("mail.smtp.auth", "true");
p.put("mail.transport.protocol", "smtp");
p.put("mail.smtp.host", "smtp.ym.163.com");
p.put("mail.smtp.port", "25");
// 建立会话
Session session = Session.getInstance(p);
Message msg = new MimeMessage(session);
// 建立信息
msg.setFrom(new InternetAddress("admin@ycombo.com"));
// 发件人
msg.setRecipient(Message.RecipientType.TO, new InternetAddress(
"lihao@ycombo.com"));
// 收件人
msg.setSentDate(new Date()); // 发送日期
msg.setSubject("答话稀有"); // 主题
msg.setText("快点下在"); // 内容
// 邮件服务器进行验证
Transport tran = session.getTransport("smtp");
tran.connect("smtp.ym.163.com", "admin@ycombo.com", "admin1234");
// bluebit_cn是用户名，xiaohao是密码
tran.sendMessage(msg, msg.getAllRecipients()); // 发送
System.out.println("邮件发送成功");
} catch (Exception e) {
e.printStackTrace();
}
}
} | ManGroup/Demo | Che/src/com/antony/mail/SendMail.java | 389 | // 发送
| line_comment | zh-cn | package com.antony.mail;
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
public class SendMail {
public static void main(String[] args) {
try {
Properties p = new Properties();
p.put("mail.smtp.auth", "true");
p.put("mail.transport.protocol", "smtp");
p.put("mail.smtp.host", "smtp.ym.163.com");
p.put("mail.smtp.port", "25");
// 建立会话
Session session = Session.getInstance(p);
Message msg = new MimeMessage(session);
// 建立信息
msg.setFrom(new InternetAddress("admin@ycombo.com"));
// 发件人
msg.setRecipient(Message.RecipientType.TO, new InternetAddress(
"lihao@ycombo.com"));
// 收件人
msg.setSentDate(new Date()); // 发送日期
msg.setSubject("答话稀有"); // 主题
msg.setText("快点下在"); // 内容
// 邮件服务器进行验证
Transport tran = session.getTransport("smtp");
tran.connect("smtp.ym.163.com", "admin@ycombo.com", "admin1234");
// bluebit_cn是用户名，xiaohao是密码
tran.sendMessage(msg, msg.getAllRecipients()); // 发送 <SUF>
System.out.println("邮件发送成功");
} catch (Exception e) {
e.printStackTrace();
}
}
} | false |
38333_13 | import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class DR {
public static void main(String[] args) throws Exception {
try {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
System.out.print("please input the name of file:");
String path = sc.next();
BasicInfo basic = new BasicInfo();
int width = basic.getWidth();
int height = basic.getHeight();
int k = basic.getK();
String distImgPath = "temp"+"//"+path.substring(0,path.indexOf("."))+".bmp";
String disTextPath = "temp"+"//"+path.substring(0,path.indexOf("."))+".txt";
Tools tool = new Tools();
// 处理成指定大小的bmp文件
tool.resizeImage(path, distImgPath, width, height);
// 再处理成纯文本的01的txt文件
tool.imageToText(distImgPath,disTextPath);
// 创建文件输入流
FileInputStream fis = new java.io.FileInputStream(disTextPath);
// 将文件流包装成一个可以写基本数据类型的输出流
@SuppressWarnings("resource")
DataInputStream dis = new java.io.DataInputStream(fis);
File f = new File(disTextPath);
int len = (int)f.length();//不一定每个文件的长度都相等！
byte[] b = new byte[len];
dis.read(b, 0, len);
// 和指定文件夹下的01文件进行比较：
String finalSrc = basic.getFinalDis();
File[] list = new File(finalSrc).listFiles();
int fileNum = list.length;
if(k>fileNum){
System.out.println("发生错误！");
System.exit(0);
}
//用一个int[文件总数]数组 record来记录对应关系，record[i] = 9 代表第i个文件的内容是9
//用一个int[文件总数]数组 result来记录距离
int[] record = new int[fileNum];
int[] result = new int[fileNum];
for(int i = 0 ;i<fileNum;i++){
//提取文件名的第一字符，其实也就是对应图片的内容。
record[i]= Integer.parseInt((String) list[i].getName().subSequence(0, 1));
result[i]= tool.compareFiles(b, list[i]);
}
//对result的colne进行排序，得到第k大的数。
int[] resultColnt = result.clone();
Arrays.sort(resultColnt);
int kNum = resultColnt[k-1];
//使用一个int[10] count的数组来进行统计。
int[] count = new int[10];
//用这个k去result中去逐个比对，比kNum小的(或是等于的)，按照对应关系，去record中得到内容。
for(int i = 0 ;i <fileNum;i++){
if(result[i]<=kNum){
count[record[i]]++;
}
}
//找到count 中最大的数，输出其下标。
int best = 0;
for(int i = 1 ;i <10;i++){
if(count[i]>count[best])
best = i;
}
System.out.println("图片的内容是："+best);
} catch (IOException e) {
System.out.println("发生错误！");
e.printStackTrace();
}
}
}
| MangoLiu/DigitRecognition | src/DR.java | 881 | //用这个k去result中去逐个比对，比kNum小的(或是等于的)，按照对应关系，去record中得到内容。 | line_comment | zh-cn | import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class DR {
public static void main(String[] args) throws Exception {
try {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
System.out.print("please input the name of file:");
String path = sc.next();
BasicInfo basic = new BasicInfo();
int width = basic.getWidth();
int height = basic.getHeight();
int k = basic.getK();
String distImgPath = "temp"+"//"+path.substring(0,path.indexOf("."))+".bmp";
String disTextPath = "temp"+"//"+path.substring(0,path.indexOf("."))+".txt";
Tools tool = new Tools();
// 处理成指定大小的bmp文件
tool.resizeImage(path, distImgPath, width, height);
// 再处理成纯文本的01的txt文件
tool.imageToText(distImgPath,disTextPath);
// 创建文件输入流
FileInputStream fis = new java.io.FileInputStream(disTextPath);
// 将文件流包装成一个可以写基本数据类型的输出流
@SuppressWarnings("resource")
DataInputStream dis = new java.io.DataInputStream(fis);
File f = new File(disTextPath);
int len = (int)f.length();//不一定每个文件的长度都相等！
byte[] b = new byte[len];
dis.read(b, 0, len);
// 和指定文件夹下的01文件进行比较：
String finalSrc = basic.getFinalDis();
File[] list = new File(finalSrc).listFiles();
int fileNum = list.length;
if(k>fileNum){
System.out.println("发生错误！");
System.exit(0);
}
//用一个int[文件总数]数组 record来记录对应关系，record[i] = 9 代表第i个文件的内容是9
//用一个int[文件总数]数组 result来记录距离
int[] record = new int[fileNum];
int[] result = new int[fileNum];
for(int i = 0 ;i<fileNum;i++){
//提取文件名的第一字符，其实也就是对应图片的内容。
record[i]= Integer.parseInt((String) list[i].getName().subSequence(0, 1));
result[i]= tool.compareFiles(b, list[i]);
}
//对result的colne进行排序，得到第k大的数。
int[] resultColnt = result.clone();
Arrays.sort(resultColnt);
int kNum = resultColnt[k-1];
//使用一个int[10] count的数组来进行统计。
int[] count = new int[10];
//用这 <SUF>
for(int i = 0 ;i <fileNum;i++){
if(result[i]<=kNum){
count[record[i]]++;
}
}
//找到count 中最大的数，输出其下标。
int best = 0;
for(int i = 1 ;i <10;i++){
if(count[i]>count[best])
best = i;
}
System.out.println("图片的内容是："+best);
} catch (IOException e) {
System.out.println("发生错误！");
e.printStackTrace();
}
}
}
| true |