text
stringlengths 10
2.72M
|
|---|
package com.pine.template.demo.old.eventbus;
/**
* Created by tanghongfeng on 2017/8/10.
*/
public class EventTwo {
private String mMsg;
public EventTwo() {
mMsg = "empty msg";
}
public EventTwo(String msg) {
mMsg = msg;
}
public String getMsg() {
return mMsg;
}
}
|
package ir.ssatari.springcommons.util.provider;
import lombok.extern.slf4j.Slf4j;
import org.jboss.vfs.VirtualFile;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
@Slf4j
public class ErrorResourceProvider {
public static final String ERROR_MESSAGES_BUNDLE_NAME = "gam-error-messages";
public static final String ERROR_MESSAGES_BUNDLE_FILE_NAME = "gam-error-messages_en.properties";
public static final String BUNDLE_ABBREVIATION = "BUNDLE_ABBREVIATION";
private Map<String, ResourceBundle> errorMessages_en = new HashMap();
private Map<String, ResourceBundle> errorMessages_fa = new HashMap();
public ErrorResourceProvider() {
}
@PostConstruct
public void init() {
this.initErrorMessagesFromPropertiesInJars();
}
private void initErrorMessagesFromPropertiesInJars() {
Enumeration errorResources = this.findAllErrorResourcePorperties();
while (errorResources.hasMoreElements()) {
URL url = (URL) errorResources.nextElement();
ErrorResourceProvider.log.debug("Found an error message bundle at [" + url + "]");
String classLoaderURL = url.toString();
try {
if (classLoaderURL.startsWith("vfs")) {
VirtualFile virtualFile = (VirtualFile) url.getContent();
((VirtualFile) (new URL(url.toString().replaceFirst("_en", "_fa"))).getContent()).getPhysicalFile().getAbsolutePath();
classLoaderURL = virtualFile.getPhysicalFile().getAbsolutePath();
classLoaderURL = "file:" + classLoaderURL.substring(0, classLoaderURL.lastIndexOf(System.getProperty("file.separator")) + 1);
} else if (classLoaderURL.startsWith("zip")) {
classLoaderURL = classLoaderURL.substring(0, url.toString().lastIndexOf("!/"));
} else if (classLoaderURL.startsWith("file")) {
classLoaderURL = classLoaderURL.substring(0, classLoaderURL.lastIndexOf("/") + 1);
}
URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL(classLoaderURL)});
ResourceBundle errorResourceBundle_en = ResourceBundle.getBundle("gam-error-messages", Locale.ENGLISH, urlClassLoader);
ResourceBundle errorResourceBundle_fa = ResourceBundle.getBundle("gam-error-messages", new Locale("fa", ""), urlClassLoader);
if (!errorResourceBundle_en.containsKey("BUNDLE_ABBREVIATION")) {
ErrorResourceProvider.log.warn("Error messages resource bundle ignored for [" + url + "] due to lack of [" + "BUNDLE_ABBREVIATION" + "] key as a mandatory property. Error messages resource bundle MUST have such key containing a three letter abbreviation of their containing module.");
} else {
String bundleAbbreviation = errorResourceBundle_en.getString("BUNDLE_ABBREVIATION");
this.errorMessages_en.put(bundleAbbreviation, errorResourceBundle_en);
this.errorMessages_fa.put(bundleAbbreviation, errorResourceBundle_fa);
ErrorResourceProvider.log.info("The error resource bundle [" + bundleAbbreviation + "] loaded from [" + url + "] added to the list of error messages providers");
}
} catch (MalformedURLException var8) {
ErrorResourceProvider.log.warn("Loading gam-error-messages_en.properties from " + url + " failed. Resource bundle would be ignored. ", var8);
} catch (IOException var9) {
var9.printStackTrace();
}
}
}
private Enumeration<URL> findAllErrorResourcePorperties() {
try {
Enumeration<URL> errorResources = Thread.currentThread().getContextClassLoader().getResources("gam-error-messages_en.properties");
return errorResources;
} catch (IOException var4) {
String message = "Unable to initialize the singleton instance of [ErrorResourceProvider] class. Scanning list of error resource bundles named gam-error-messages_en.properties in jar files failed";
ErrorResourceProvider.log.error(message, var4);
throw new RuntimeException(message, var4);
}
}
public void addErrorResourceBundle(String name, ResourceBundle errorResourceBundle) {
if (errorResourceBundle.getLocale().getLanguage().equals("fa")) {
this.errorMessages_fa.put(name.toUpperCase(), errorResourceBundle);
} else if (errorResourceBundle.getLocale().getLanguage().equals("en")) {
this.errorMessages_en.put(name.toUpperCase(), errorResourceBundle);
} else {
ErrorResourceProvider.log.warn("Resource bundle [{}] is in [{}] language. Only 'fa' or 'en' languages are acceptable");
}
}
public boolean hasResourceBundle(String name) {
return this.errorMessages_en.containsKey(name.toUpperCase());
}
public String getErrorMessage(String errorCode, Locale locale) {
String result = null;
ResourceBundle bundle;
if (locale != null && !locale.getLanguage().equals("en")) {
bundle = this.errorMessages_fa.get(errorCode.substring(0, 3).toUpperCase());
} else {
bundle = this.errorMessages_en.get(errorCode.substring(0, 3).toUpperCase());
}
if (bundle != null && bundle.containsKey(errorCode)) {
result = bundle.getString(errorCode);
}
return result;
}
public String getErrorMessage(String errorCode) {
String result = null;
ResourceBundle bundle = this.errorMessages_en.get(errorCode.substring(0, 3).toUpperCase());
if (bundle != null && bundle.containsKey(errorCode)) {
result = bundle.getString(errorCode);
}
return result;
}
public Map<String, ResourceBundle> getErrorMessages() {
return this.errorMessages_en;
}
public Map<String, ResourceBundle> getErrorMessages(Locale locale) {
return locale.getLanguage().equals("en") ? this.errorMessages_en : this.errorMessages_fa;
}
}
|
package com.ccxia.cbcraft.tileentity;
import java.util.ArrayList;
import java.util.List;
import com.ccxia.cbcraft.block.BlockFermentationBaker;
import com.ccxia.cbcraft.block.BlockSeparator;
import com.ccxia.cbcraft.tileentity.crafting.CraftingSeparator;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBoat;
import net.minecraft.item.ItemDoor;
import net.minecraft.item.ItemHoe;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemSword;
import net.minecraft.item.ItemTool;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.NonNullList;
import net.minecraft.util.math.MathHelper;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.ItemStackHandler;
public class TileEntitySeparator extends TileEntity implements ITickable {
// 分离机的底部成品位置有两个物品槽，输出两种成品
protected ItemStackHandler upInventory = new ItemStackHandler();
protected ItemStackHandler sideInventory = new ItemStackHandler();
protected ItemStackHandler downInventory = new ItemStackHandler(2);
private NonNullList<ItemStack> separatorItemStacks = NonNullList.<ItemStack>withSize(4, ItemStack.EMPTY);
private int furnaceBurnTime;
private int currentItemBurnTime;
private int cookTime;
private int totalCookTime;
@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
if (CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.equals(capability)) {
return true;
}
return super.hasCapability(capability, facing);
}
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
if (CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.equals(capability)) {
// @SuppressWarnings("unchecked")
if (facing == EnumFacing.UP)
return (T) upInventory;
else if (facing == EnumFacing.DOWN)
return (T) downInventory;
else
return (T) sideInventory;
}
return super.getCapability(capability, facing);
}
@Override
public void update() {
boolean flag = this.isBurning();
boolean flag1 = false;
if (this.isBurning()) {
--this.furnaceBurnTime;
}
if (!this.world.isRemote) {
ItemStack itemstack = this.sideInventory.getStackInSlot(0);
if (this.isBurning()
|| !itemstack.isEmpty() && !((ItemStack) this.upInventory.getStackInSlot(0)).isEmpty()) {
if (!this.isBurning() && this.canSmelt()) {
this.furnaceBurnTime = getItemBurnTime(itemstack);
this.currentItemBurnTime = this.furnaceBurnTime;
if (this.isBurning()) {
flag1 = true;
if (!itemstack.isEmpty()) {
Item item = itemstack.getItem();
itemstack.shrink(1);
if (itemstack.isEmpty()) {
ItemStack item1 = item.getContainerItem(itemstack);
this.sideInventory.setStackInSlot(0, item1);
}
}
}
}
// 这一部分判定为正式进入烧炼过程
if (this.isBurning() && this.canSmelt()) {
this.totalCookTime = this.getCookTime(this.upInventory.getStackInSlot(0));
++this.cookTime;
// 当烧炼时间到时执行转换操作
if (this.cookTime == this.totalCookTime) {
this.cookTime = 0;
this.totalCookTime = this.getCookTime(this.upInventory.getStackInSlot(0));
this.smeltItem();
flag1 = true;
}
} else {
this.cookTime = 0;
}
} else if (!this.isBurning() && this.cookTime > 0) {
this.cookTime = MathHelper.clamp(this.cookTime - 2, 0, this.totalCookTime);
}
if (flag != this.isBurning()) {
flag1 = true;
BlockSeparator.setState(this.isBurning(), this.world, this.pos);
}
}
if (flag1) {
this.markDirty();
}
}
public int getSizeInventory() {
return separatorItemStacks.size();
}
public int getInventoryStackLimit() {
return 64;
}
@Override
public void readFromNBT(NBTTagCompound compound) {
super.readFromNBT(compound);
}
@Override
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
super.writeToNBT(compound);
return compound;
}
public int getCookTime(ItemStack stack) {
return 200;
}
public boolean isBurning() {
return this.furnaceBurnTime > 0;
}
private boolean canSmelt() {
// 原料为空直接返回false
if (upInventory.getStackInSlot(0).isEmpty()) {
return false;
}
ItemStack itemStack1 = upInventory.extractItem(0, 1, true);
List<ItemStack> result = CraftingSeparator.instance().getSmeltItems(itemStack1);
if (result.get(0) == ItemStack.EMPTY) {
return false;
} else {
ItemStack itemStack2 = result.get(0);
ItemStack itemStack3 = result.get(1);
ItemStack itemStack4 = downInventory.extractItem(0, 1, true);
ItemStack itemStack5 = downInventory.extractItem(1, 1, true);
// 两个成品槽均为空返回true
// 一个成品槽为空，另一个成品槽种类相同且符合堆叠返回true
// 两个成品槽物品种类相同且符合堆叠返回true
// 其余返回false
if (itemStack4.isEmpty() && itemStack5.isEmpty()) {
return true;
} else if (itemStack4.isEmpty() && itemStack3.isItemEqual(itemStack5)
&& itemStack3.getCount() + itemStack5.getCount() <= this.getInventoryStackLimit()
&& itemStack3.getCount() + itemStack5.getCount() <= itemStack3.getMaxStackSize()) {
return true;
} else if (itemStack5.isEmpty() && itemStack2.isItemEqual(itemStack4)
&& itemStack2.getCount() + itemStack4.getCount() <= this.getInventoryStackLimit()
&& itemStack4.getCount() + itemStack4.getCount() <= itemStack4.getMaxStackSize()) {
return true;
} else if (itemStack3.isItemEqual(itemStack5)
&& itemStack3.getCount() + itemStack5.getCount() <= this.getInventoryStackLimit()
&& itemStack3.getCount() + itemStack5.getCount() <= itemStack3.getMaxStackSize()
&& itemStack2.isItemEqual(itemStack4)
&& itemStack2.getCount() + itemStack4.getCount() <= this.getInventoryStackLimit()
&& itemStack4.getCount() + itemStack4.getCount() <= itemStack4.getMaxStackSize()) {
return true;
} else {
return false;
}
}
}
public void smeltItem() {
if (this.canSmelt()) {
ItemStack itemStack1 = upInventory.extractItem(0, 1, true);
List<ItemStack> result = CraftingSeparator.instance().getSmeltItems(itemStack1);
ItemStack itemStack2 = result.get(0);
ItemStack itemStack3 = result.get(1);
if (itemStack2 != ItemStack.EMPTY) {
upInventory.extractItem(0, 1, false);
downInventory.insertItem(0, itemStack2.copy(), false);
downInventory.insertItem(1, itemStack3.copy(), false);
}
}
}
public static int getItemBurnTime(ItemStack stack) {
if (stack.isEmpty()) {
return 0;
} else {
int burnTime = net.minecraftforge.event.ForgeEventFactory.getItemBurnTime(stack);
if (burnTime >= 0)
return burnTime;
Item item = stack.getItem();
if (item == Item.getItemFromBlock(Blocks.WOODEN_SLAB)) {
return 150;
} else if (item == Item.getItemFromBlock(Blocks.WOOL)) {
return 100;
} else if (item == Item.getItemFromBlock(Blocks.CARPET)) {
return 67;
} else if (item == Item.getItemFromBlock(Blocks.LADDER)) {
return 300;
} else if (item == Item.getItemFromBlock(Blocks.WOODEN_BUTTON)) {
return 100;
} else if (Block.getBlockFromItem(item).getDefaultState().getMaterial() == Material.WOOD) {
return 300;
} else if (item == Item.getItemFromBlock(Blocks.COAL_BLOCK)) {
return 16000;
} else if (item instanceof ItemTool && "WOOD".equals(((ItemTool) item).getToolMaterialName())) {
return 200;
} else if (item instanceof ItemSword && "WOOD".equals(((ItemSword) item).getToolMaterialName())) {
return 200;
} else if (item instanceof ItemHoe && "WOOD".equals(((ItemHoe) item).getMaterialName())) {
return 200;
} else if (item == Items.STICK) {
return 100;
} else if (item != Items.BOW && item != Items.FISHING_ROD) {
if (item == Items.SIGN) {
return 200;
} else if (item == Items.COAL) {
return 1600;
} else if (item == Items.LAVA_BUCKET) {
return 20000;
} else if (item != Item.getItemFromBlock(Blocks.SAPLING) && item != Items.BOWL) {
if (item == Items.BLAZE_ROD) {
return 2400;
} else if (item instanceof ItemDoor && item != Items.IRON_DOOR) {
return 200;
} else {
return item instanceof ItemBoat ? 400 : 0;
}
} else {
return 100;
}
} else {
return 300;
}
}
}
public static boolean isItemFuel(ItemStack stack) {
return getItemBurnTime(stack) > 0;
}
public int getTime(int index) {
switch (index) {
case 0:
return this.furnaceBurnTime;
case 1:
return this.currentItemBurnTime;
case 2:
return this.cookTime;
case 3:
return this.totalCookTime;
default:
return 0;
}
}
}
|
package org.xgame.commons.generator;
import java.util.concurrent.atomic.AtomicLong;
/**
* @Company: 深圳市烈焰时代科技有限公司
* @Product: flame-gxnjy
* @File: com.flame.game.core.aacommon.generate.TempLongIDGen.java
* @Description: 临时的longID 生成器,从1开始自增，每次服务器重启之后从新开始，
* 不能用于需要在服务器重启之后还需要维持的Id， 需要的话请使用另外一个 LongIDGen
* @Create: DerekWu 2017年8月8日 上午10:36:26
* @version: V1.0
*/
public class TempLongIDGen {
/** ID值 */
private static final AtomicLong value = new AtomicLong(0);
/**
* 生成临时的 LongID
* @return
*/
public static long gen() {
return value.incrementAndGet();
}
}
|
package com.kingtime.freeweather.ui;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import com.kingtime.freeweather.R;
import com.kingtime.freeweather.api.ApiClient;
import com.kingtime.freeweather.app.WeatherApplication;
import com.kingtime.freeweather.entity.BaseLocation;
import com.kingtime.freeweather.entity.WeatherInfo;
import com.kingtime.freeweather.utils.FileUtils;
import com.kingtime.freeweather.utils.StreamTool;
import com.kingtime.freeweather.utils.StringUtils;
import com.kingtime.freeweather.utils.XMLReader;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity {
private WeatherApplication weatherApplication;
private TextView statusTextView;
private Button parseDataButton;
private Spinner provinceSpinner;
private Spinner citySpinner;
private TextView weatherInfoTextView;
private Button showSuggestButton;
private Button showWeatherButton;
private final static String TAG = "MainActivity";
private List<BaseLocation> provinceList;
private List<BaseLocation> cityList;
private List<String> weatherList;
private WeatherInfo info;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
System.out.println(TAG + " start!");
weatherApplication = (WeatherApplication) getApplication();
initView();
// loadData();
}
private void initView() {
statusTextView = (TextView) findViewById(R.id.status_tv);
parseDataButton = (Button) findViewById(R.id.prase_btn);
provinceSpinner = (Spinner) findViewById(R.id.province_sp);
citySpinner = (Spinner) findViewById(R.id.city_sp);
weatherInfoTextView = (TextView) findViewById(R.id.weather_info_tv);
showSuggestButton = (Button) findViewById(R.id.suggest_btn);
showWeatherButton = (Button) findViewById(R.id.weather_btn);
parseDataButton.setOnClickListener(listener);
provinceSpinner.setOnItemSelectedListener(spListener);
citySpinner.setOnItemSelectedListener(cpListener);
showSuggestButton.setOnClickListener(listener);
showWeatherButton.setOnClickListener(listener);
provinceList = new ArrayList<BaseLocation>();
cityList = new ArrayList<BaseLocation>();
weatherList = new ArrayList<String>();
}
private void loadData() {
final Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
InputStream provinceStream = (InputStream) msg.obj;
String provinceXML = null;
try {
byte data[] = null;
data = StreamTool.read(provinceStream);
provinceXML = new String(data);
System.out.println(provinceXML);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
String dataLoadTips = "Data not load!";
if (!StringUtils.isEmpty(provinceXML)) {
FileUtils.write(getApplicationContext(),
"RegionProvince.xml", provinceXML);
dataLoadTips = "Data has loaded!";
}
statusTextView.setText(dataLoadTips);
super.handleMessage(msg);
}
};
new Thread() {
public void run() {
InputStream provinceStream = null;
try {
provinceStream = ApiClient.getRegionProvince();
byte[] data1 = StreamTool.read(ApiClient
.getSupportCity(31118));
byte[] data2 = StreamTool.read(ApiClient.getWeather(1701));
FileUtils.write(getApplicationContext(), "SupportCity.xml",
new String(data1));
FileUtils.write(getApplicationContext(),
"FengHuangWeather.xml", new String(data2));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Message msg = new Message();
msg.obj = provinceStream;
handler.sendMessage(msg);
};
}.start();
}
private OnClickListener listener = new OnClickListener() {
@Override
public void onClick(View v) {
if (v.getId() == R.id.prase_btn) {
String provinceString = FileUtils.read(getApplicationContext(),
"RegionProvince.xml");
// System.out.println(provinceString);
if (!StringUtils.isEmpty(provinceString)) {
try {
System.out.println("Start parsing province...");
provinceList = BaseLocation.toBaseLocations(XMLReader
.readToStringList(provinceString));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ArrayAdapter<String> adapter = new ArrayAdapter<String>(
getApplicationContext(),
android.R.layout.simple_spinner_item,
BaseLocation.baseNames(provinceList));
provinceSpinner.setAdapter(adapter);
}
}
if (v.getId() == R.id.suggest_btn) {
weatherApplication.dataMap.put("localWeatherInfo", info);
startActivity(new Intent(MainActivity.this,
SecondActivity.class));
}
if (v.getId() == R.id.weather_btn) {
startActivity(new Intent(MainActivity.this,
WeatherActivity.class));
}
}
};
private OnItemSelectedListener spListener = new OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view,
final int position, long id) {
Toast.makeText(getApplicationContext(),
"Get " + provinceList.get(position).getBaseName(),
Toast.LENGTH_SHORT).show();
final Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
String cityString = FileUtils.read(getApplicationContext(),
provinceList.get(position).getBaseName() + ".xml");
if (!StringUtils.isEmpty(cityString)) {
try {
System.out.println("Start parsing city...");
cityList = BaseLocation.toBaseLocations(XMLReader
.readToStringList(cityString));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ArrayAdapter<String> adapter = new ArrayAdapter<String>(
getApplicationContext(),
android.R.layout.simple_spinner_dropdown_item,
BaseLocation.baseNames(cityList));
citySpinner.setAdapter(adapter);
}
super.handleMessage(msg);
}
};
new Thread() {
public void run() {
try {
byte[] data1 = StreamTool.read(ApiClient
.getSupportCity(provinceList.get(position)
.getBaseCode()));
FileUtils.write(getApplicationContext(), provinceList
.get(position).getBaseName() + ".xml",
new String(data1));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
handler.sendEmptyMessage(0);
};
}.start();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
// TODO Auto-generated method stub
}
};
private OnItemSelectedListener cpListener = new OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view,
final int position, long id) {
final Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
String weatherString = FileUtils.read(
getApplicationContext(), cityList.get(position)
.getBaseName() + ".xml");
if (!StringUtils.isEmpty(weatherString)) {
try {
System.out.println("Start parsing weather info...");
weatherList = XMLReader
.readToStringList(weatherString);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
StringBuffer weatherBuffer = new StringBuffer();
weatherBuffer.append("Lines:" + weatherList.size())
.append("\n");
info = new WeatherInfo(weatherList);
weatherBuffer.append("LastRefresh time:"
+ info.getLastRefreshTime());
for (String weatherInfo : weatherList) {
weatherBuffer.append(weatherInfo).append("\n");
}
weatherInfoTextView.setText(weatherBuffer.toString());
}
super.handleMessage(msg);
}
};
new Thread() {
public void run() {
try {
byte[] data1 = StreamTool.read(ApiClient
.getWeather(cityList.get(position)
.getBaseCode()));
FileUtils.write(getApplicationContext(),
cityList.get(position).getBaseName() + ".xml",
new String(data1));
handler.sendEmptyMessage(0);
} catch (Exception e) {
// TODO Auto-generated catch block
Toast.makeText(getApplicationContext(),
"Failed to get the weather infomation!",
Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
};
}.start();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
// TODO Auto-generated method stub
}
};
}
|
package removeadjcent;
public class Solution {
public String deDup(String input) {
// Write your solution here.
if(input == null|| input.length() == 0){
return null;
}
char [] array = input.toCharArray();
//char [] p = input.toCharArray();
int slow = 0;
//!!!array[fast]!=array[slow-1]
for(int fast = 0; fast < array.length; fast++){
if (slow == 0 || array[slow - 1] != array[fast]){
array[slow] = array[fast];
slow++;
}
}
return new String(array, 0 ,slow);
}
}
|
package sevenkyu.complementarydna;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class ComplementaryDna {
static final Map<Character, Character> COMPLEMENTS = Map.of('T', 'A', 'A', 'T', 'G', 'C', 'C', 'G');
public String makeComplement(String dna) {
return IntStream.range(0, dna.length())
.mapToObj(dna::charAt)
.map(COMPLEMENTS::get)
.map(Object::toString)
.collect(Collectors.joining());
}
}
|
package com.example.demo317;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import android.widget.ImageView;
//import org.json.JSONObject;
import net.sf.json.JSONObject;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TCPSocket {
private ExecutorService mThreadPool;
public Socket socket;
private InputStreamReader isr;
private String response;
private InputStream is;
private BufferedReader br;
public Bitmap bmp = null;
private ImageView imageView = null;//定义图片变量
private OutputStream outputStream;
private Lock lock = new ReentrantLock();
public TCPSocket() throws IOException {
// 初始化线程池
lock.lock();//上锁
mThreadPool = Executors.newCachedThreadPool();
try {
Log.d("TCP", "初始化前socket为"+String.valueOf(socket));
// 创建Socket对象 & 指定服务端的IP 及 端口号
// socket = new Socket("111.229.197.188", 12345); //服务器IP及端口
socket = new Socket("192.168.0.106", 12345); //服务器IP及端口
Log.d("TCP", "初始化后socket为"+String.valueOf(socket));
// 判断客户端和服务器是否连接成功
System.out.println(socket.isConnected());
} catch (IOException e) {
e.printStackTrace();
}
lock.unlock();
}
public synchronized void tcpsendstring(final String mes) {//发送字符串
mThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
Log.d("TCP","发送字符前为"+ String.valueOf(socket));
while (socket == null);//等待初始化完成
Log.d("TCP","发送字符时为"+ String.valueOf(socket));
// 步骤1：从Socket 获得输出流对象OutputStream
// 该对象作用：发送数据
outputStream = socket.getOutputStream();
// 步骤2：写入需要发送的数据到输出流对象中
outputStream.write((mes + "\n").getBytes());
// 特别注意：数据的结尾加上换行符才可让服务器端的readline()停止阻塞
// 步骤3：发送数据到服务端
outputStream.flush();
Log.d("TCP","发送字符完成");
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
public void tcpjsonrecieve() throws IOException {
isr=new InputStreamReader(socket.getInputStream());
br=new BufferedReader(isr);
String str=br.readLine();
}
public synchronized Bitmap tcprecievephoto() {
while(socket==null);
bmp=null;
try {
Log.d("TCP", "进入图片接受");
tcpsendstring("4442");
DataInputStream dataInput = new DataInputStream(socket.getInputStream());
int size = dataInput.readInt();
Log.d("TCP1", "接收图片大小为"+String.valueOf(size));
byte[] data = new byte[size];
int len = 0;
while (len < size) {
len += dataInput.read(data, len, size - len);
}
ByteArrayOutputStream outPut = new ByteArrayOutputStream();
bmp = BitmapFactory.decodeByteArray(data, 0, data.length);
bmp.compress(Bitmap.CompressFormat.PNG, 100, outPut);
dataInput.close();
outPut.close();
//imageView.setImageBitmap(bmp);
// handler.post(runnableUi);//使用主线程改变控件imageview
//Bitmap bitmap = BitmapFactory.decodeStream(dataInput);
//myHandler.obtainMessage().sendToTarget();
} catch (IOException e) {
e.printStackTrace();
}
Log.d("TCP6", "图片数据为"+String.valueOf(bmp));
return bmp;
}
public synchronized void tcprecievejson() {
bmp=null;
mThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
Log.d("TCP1", "进入json接收");
tcpsendstring("01");
while(socket==null);
Log.d("TCP1", "进入");
DataInputStream in;
String str;
in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
str=in.readUTF();
System.out.println("tcp输入信息为："+str);
JSONObject js =JSONObject.fromObject(str);
Log.d("TCP1jiesh", "进入json接收"+js.getString("string"));
/*
DataInputStream dataInput = new DataInputStream(socket.getInputStream());
int size = dataInput.readInt();
Log.d("TCP1", String.valueOf(size));
byte[] data = new byte[size];
int len = 0;
while (len < size) {
len += dataInput.read(data, len, size - len);
}
Log.d("TCP1接收到的数据", ""+data);
ByteArrayOutputStream outPut = new ByteArrayOutputStream();
System.out.println("类容 = " + data);
JSONObject jsonobject =JSONObject.fromObject(data.toString());
Log.d("TCP1jiesh", "进入json接收"+jsonobject.getString("string"));
bmp = BitmapFactory.decodeByteArray(data, 0, data.length);
bmp.compress(Bitmap.CompressFormat.PNG, 100, outPut);
dataInput.close();
outPut.close();*/
//imageView.setImageBitmap(bmp);
// handler.post(runnableUi);//使用主线程改变控件imageview
//Bitmap bitmap = BitmapFactory.decodeStream(dataInput);
//myHandler.obtainMessage().sendToTarget();
} catch (IOException e) {
e.printStackTrace();
}
}
});
Log.d("TCP6", String.valueOf(bmp));
}
public synchronized void tcpreceive() {
mThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
while(socket==null);
tcpsendstring("01");
// 步骤1：创建输入流对象InputStream
is = socket.getInputStream();
// 步骤2：创建输入流读取器对象 并传入输入流对象
// 该对象作用：获取服务器返回的数据
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
Log.d("TCP准备读取", "response");
// 步骤3：通过输入流读取器对象 接收服务器发送过来的数据
response = br.readLine();
// 步骤4:通知主线程,将接收的消息显示到界面
Log.d("TCP数据", response);
is.close();
isr.close();
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
}
|
package com.goodhealth.comm.util.redis;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
import java.nio.charset.Charset;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* redis工具类，方法定义：http://doc.redisfans.com
*
* @author WDH
* @date 2018年1月30日
*/
@Service
@Component
@Slf4j
public class RedisService {
@Autowired
StringRedisTemplate stringRedisTemplate;
private RedisLock redisLock = new RedisLock();
/**
* 留白用于对key预处理
* @param key
* @return
*/
private String keyHandle(String key) {
return "" + key;
}
/******************* key **********************/
/**
* 删除key
* @date 2018年1月30日
*/
public void del(String key) {
stringRedisTemplate.delete(keyHandle(key));
}
/**
* 批量删除key
* @date 2018年1月30日
*/
public void batchDel(Collection<String> keys) {
List<String> campusKeys = new ArrayList<>();
keys.forEach(e-> campusKeys.add(keyHandle(e)));
stringRedisTemplate.delete(campusKeys);
}
/**
* 检查给定 key是否存在
* @date 2018年1月30日
*/
public Boolean exists(String key) {
return stringRedisTemplate.hasKey(keyHandle(key));
}
/**
* 设置过期时间
* @param timeout 单位秒
*/
public Boolean expire(String key, long timeout) {
return stringRedisTemplate.expire(keyHandle(key), timeout, TimeUnit.SECONDS);
}
/**
* 设置过期时间 自定义时间单位
* @param timeUnit 时间单位
*/
public Boolean expire(String key, long timeout, TimeUnit timeUnit) {
return stringRedisTemplate.expire(keyHandle(key), timeout, timeUnit);
}
/**
* 设置过期时间 在某一天
* @param date 时间
*/
public Boolean expireAt(String key, Date date) {
return stringRedisTemplate.expireAt(keyHandle(key), date);
}
/**
* 返回给定 key 的剩余生存时间,以秒为单位
*
* @param
*/
public Long ttl(String key) {
return stringRedisTemplate.getExpire(keyHandle(key));
}
/**
* 修改 key
* @param key
* @return
*/
public void rename(String key,String newKey){
stringRedisTemplate.boundValueOps(key).rename(newKey);
}
/******************* key----String **********************/
/**
* 将 key所储存的值加上增量 delta,返回增加后的值
* @param
*/
public Long incrBy(String key, long delta) {
return stringRedisTemplate.opsForValue().increment(keyHandle(key), delta);
}
/**
* 将字符串值 value 关联到 key
* @param
*/
public void set(String key, String value) {
stringRedisTemplate.opsForValue().set(keyHandle(key), value);
}
/**
* 有失效时间的设置k-v
* @param key
* @param value
* @param expire
* @param timeUnit
*/
public void set(String key, String value, long expire, TimeUnit timeUnit) {
stringRedisTemplate.opsForValue().set(keyHandle(key), value, expire, timeUnit);
}
/**
* 将 key的值设为 value ，当且仅当 key 不存在
* @param
*/
public Boolean setOnlyWhenExist(String key, String value) {
return stringRedisTemplate.opsForValue().setIfAbsent(keyHandle(key), value);
}
/**
* 批量关联到 key
* @param map <k,v>键值对
*/
public void mset(Map<String, String> map) {
stringRedisTemplate.opsForValue().multiSet(map);
}
/**
* 返回 key所关联的字符串
* @date 2018年1月30日
* @param
*/
public String get(String key) {
return stringRedisTemplate.opsForValue().get(keyHandle(key));
}
/******************* key---Hash **********************/
/**
* 删除哈希表 key中的一个或多个指定域，不存在的域将被忽略
* @date 2018年1月30日
* @param fields 变长参数
*/
public Long hdel(String key, Object... fields) {
return stringRedisTemplate.opsForHash().delete(keyHandle(key), fields);
}
/**
* 将哈希表 key中的域 field 的值设为 value
* @param
*/
public void hset(String key, String field, String hashValue) {
stringRedisTemplate.opsForHash().put(keyHandle(key), field, hashValue);
}
/**
* 同时将多个 field-value (域-值)对设置到哈希表 key 中
* @date 2018年1月30日
* @param
*/
public void hmset(String key, Map<String, String> map) {
stringRedisTemplate.opsForHash().putAll(keyHandle(key), map);
}
/**
* 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在
* @param
*/
public Boolean hsetOnlyWhenNotExist(String key, String field, String hashValue) {
return stringRedisTemplate.opsForHash().putIfAbsent(keyHandle(key), field, hashValue);
}
/**
* 返回哈希表 key 中给定域 field 的值
* @date 2018年1月30日
* @param
*/
public String hget(String key, String field) {
return (String) stringRedisTemplate.opsForHash().get(keyHandle(key), field);
}
/**
* 返回哈希表 key 中，所有的域和值
* @param
*/
public Map<Object, Object> hgetAll(String key) {
return stringRedisTemplate.opsForHash().entries(keyHandle(key));
}
/**
* 返回哈希表 key 中的所有field
* @param
*/
public Set<Object> getHkeysFields(String key) {
return stringRedisTemplate.opsForHash().keys(keyHandle(key));
}
/**
* 返回哈希表 key 中所有field的值
* @param
*/
public List<Object> getHkeysValues(String key) {
return stringRedisTemplate.opsForHash().values(keyHandle(key));
}
/**
* 为哈希表 key 中的域 field 的值加上增量 delta
* @param
*/
public Long hincrBy(String key, String field, long delta) {
return stringRedisTemplate.opsForHash().increment(keyHandle(key), field, delta);
}
/**
* 查看哈希表 key 中，给定域 field 是否存在
* @param
*/
public Boolean hexists(final String key, String hashKey) {
return stringRedisTemplate.opsForHash().hasKey(keyHandle(key), hashKey);
}
/******************* key---List **********************/
// list入队顺序 a b c d ---> d c b a 从左到右进队列
/**
* 删除并获取列表中的第一个元素
* 左出队列
* @param
*/
public String lpop(String key) {
return stringRedisTemplate.opsForList().leftPop(keyHandle(key));
}
/**
* 删除并获取列表中的第一个元素，或阻塞，直到有一个元素可用
* 右出队列
* @param
*/
public String blockLpop(String key, long timeout, TimeUnit unit) {
return stringRedisTemplate.opsForList().leftPop(keyHandle(key), timeout, unit);
}
/**
* 删除并获取列表中的最后一个元素
* @param
*/
public String rpop(String key) {
return stringRedisTemplate.opsForList().rightPop(keyHandle(key));
}
/**
* 删除并获取列表中的最后一个元素，或阻塞，直到有一个元素可用
* @param
*/
public String blockRpop(String key, long timeout, TimeUnit unit) {
return stringRedisTemplate.opsForList().rightPop(keyHandle(key), timeout, unit);
}
/**
* 返回列表 key 的长度
* @param
*/
public Long llen(String key) {
return stringRedisTemplate.opsForList().size(keyHandle(key));
}
/**
* 将value 插入到列表 key 的表头
* @param
*/
public Long lpush(String key, String value) {
return stringRedisTemplate.opsForList().leftPush(keyHandle(key), value);
}
/**
* 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表
* @param
*/
public Long lpushWhenExist(String key, String value) {
return stringRedisTemplate.opsForList().leftPushIfPresent(keyHandle(key), value);
}
/**
* 将value 插入到列表 key 的表尾
* @param
*/
public Long rpush(String key, String value) {
return stringRedisTemplate.opsForList().rightPush(keyHandle(key), value);
}
/**
* 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表
* @param
*/
public Long rpushWhenExist(String key, String value) {
return stringRedisTemplate.opsForList().rightPushIfPresent(keyHandle(key), value);
}
/**
* 获取指定区间的value 下标从零开始
* @param key
* @param begin
* @param end
* @return
*/
public List<String> lrange(String key, long begin,long end) {
return stringRedisTemplate.opsForList().range(keyHandle(key), begin, end);
}
/******************* key---Set **********************/
/**
* 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略
* @param
*/
public Long batchAddSkey(String key, String... values) {
return stringRedisTemplate.opsForSet().add(keyHandle(key), values);
}
/**
* 返回集合 key 的基数(集合中元素的数量)
* @param
*/
public Long sizeSkey(String key) {
return stringRedisTemplate.opsForSet().size(keyHandle(key));
}
/**
* 返回一个集合的全部成员，该集合是所有给定集合之间的差集
* @param
*/
public Set<String> sDiff(String key, String otherKey) {
return stringRedisTemplate.opsForSet().difference(keyHandle(key), otherKey);
}
/**
* 返回一个集合的全部成员，该集合是所有给定集合之间的差集
* @param
*/
public Set<String> sDiff(String key, Collection<String> otherKeys) {
return stringRedisTemplate.opsForSet().difference(keyHandle(key), otherKeys);
}
/**
* 返回一个集合的全部成员，该集合是所有给定集合的交集
* @param
*/
public Set<String> sInter(String key, String otherKey) {
return stringRedisTemplate.opsForSet().intersect(keyHandle(key), otherKey);
}
/**
* 返回一个集合的全部成员，该集合是所有给定集合的交集
* @param
*/
public Set<String> sInter(String key, Collection<String> otherKeys) {
return stringRedisTemplate.opsForSet().intersect(keyHandle(key), otherKeys);
}
/**
* 判断 member 元素是否集合 key 的成员
* @param
*/
public Boolean sIsMember(String key, String member) {
return stringRedisTemplate.opsForSet().isMember(keyHandle(key), member);
}
/**
* 返回集合 key 中的所有成员
* @param
*/
public Set<String> sMembers(String key) {
return stringRedisTemplate.opsForSet().members(keyHandle(key));
}
/**
* 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
* @param
*/
public Long sRemove(String key, String... values) {
return stringRedisTemplate.opsForSet().remove(keyHandle(key), values);
}
/**
* 返回一个集合的全部成员，该集合是所有给定集合的并集
* @param
*/
public Set<String> sUnion(String key, String otherKey) {
return stringRedisTemplate.opsForSet().union(keyHandle(key), otherKey);
}
/**
* 返回一个集合的全部成员，该集合是所有给定集合的并集
* @param
*/
public Set<String> sUnion(String key, Collection<String> otherKeys) {
return stringRedisTemplate.opsForSet().union(keyHandle(key), otherKeys);
}
/******************* key---Zset **********************/
/**
* 将一个或多个 member 元素及其 score 值加入到有序集 key 当中v
* @param
*/
public Boolean zAdd(String key, String value, double score) {
return stringRedisTemplate.opsForZSet().add(keyHandle(key), value, score);
}
/**
* 返回有序集 key 元素的个数
* @param
*/
public Long zcard(String key) {
return stringRedisTemplate.opsForZSet().zCard(keyHandle(key));
}
/**
* 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max)的成员的数量
* @param
*/
public Long zCount(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().count(keyHandle(key), min, max);
}
/**
* 为有序集 key 的成员 member 的 score 值加上增量 delta
* @param
*/
public Double zIncrby(String key, String value, double delta) {
return stringRedisTemplate.opsForZSet().incrementScore(keyHandle(key), value, delta);
}
/**
* 返回有序集 key 中，指定区间内的成员,
* 其中成员的位置按 score 值递增(从小到大)来排序
* @param
*/
public Set<String> zRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().range(keyHandle(key), start, end);
}
/**
* 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max)的成员。有序集成员按
* score,值递增(从小到大)次序排列
* @param
*/
public Set<String> zRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().rangeByScore(keyHandle(key), min, max);
}
/**
* 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
* 排名以 0 为底
* @param
*/
public Long zRank(String key, String member) {
return stringRedisTemplate.opsForZSet().rank(keyHandle(key), member);
}
/**
* 移除有序集 key 中，指定排名(rank)区间内的所有成员
* @param
*/
public Long zRemoveRangeByRank(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().removeRange(keyHandle(key), start, end);
}
/**
* 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员
* @param
*/
public Long zRemoveRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().removeRangeByScore(keyHandle(key), min, max);
}
/**
* 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递减(从大到小)来排列。
* @param
*/
public Set<String> zReverseRange(String key, long start, long end) {
return stringRedisTemplate.opsForZSet().reverseRange(keyHandle(key), start, end);
}
/**
* 返回有序集 key 中， score 值介于 max 和 min 之间(默认包括等于 max 或 min)的所有的成员。
* 有序集成员按score,值递减(从大到小)的次序排列
* @param
*/
public Set<String> zReverseRangeByScore(String key, double min, double max) {
return stringRedisTemplate.opsForZSet().reverseRangeByScore(keyHandle(key), min, max);
}
/**
* 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。排名以 0 为底
* @param
*/
public Long zrevrank(String key, String member) {
return stringRedisTemplate.opsForZSet().reverseRank(keyHandle(key), member);
}
/**
* 返回有序集 key 中，成员 member 的 score 值
* @param
*/
public Double zscore(String key, String member) {
return stringRedisTemplate.opsForZSet().score(keyHandle(key), member);
}
/******************* Pub/Sub **********************/
/**
* 将信息 message 发送到指定的频道 channel
* @param
*/
public void publish(String channel, String message) {
stringRedisTemplate.convertAndSend(channel, message);
}
/******************* serial **********************/
/**
* 获取redisTemplate的序列化
* @param
*/
public RedisSerializer<String> getSerializer() {
return stringRedisTemplate.getStringSerializer();
}
public boolean lock(String key,int timeout) throws InterruptedException {
return redisLock.lock(keyHandle(key),timeout);
}
public boolean unlock(String key) {
return redisLock.unlock(keyHandle(key));
}
class RedisLock {
private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;
// /**
// * Lock key path.
// */
// private String lockKey;
/**
* 锁超时时间，防止线程在入锁以后，无限的执行等待
*/
private int expireMsecs = 30 * 1000;
/**
* 锁等待时间，防止线程饥饿
*/
private int timeoutMsecs = 5 * 1000;
private String get(final String key) {
return stringRedisTemplate.opsForValue().get(keyHandle(key));
}
private boolean setNX(final String key, final String value) {
return stringRedisTemplate.opsForValue().setIfAbsent(keyHandle(key), value);
}
private boolean setNX(final String key,int expireSecs) {
// RedisCallback<String> callback2 = new RedisCallback<String>() {
// @Override
// public String doInRedis(RedisConnection connection) throws DataAccessException {
// JedisCommands commands = (JedisCommands) connection.getNativeConnection();
// return commands.set(RedisLock.this.keyHandle(key), "1", "NX", "EX", expireSecs);
// }
// };
// RedisCallback<String> callback = (connection) -> {
// JedisCommands commands = (JedisCommands) connection.getNativeConnection();
// return commands.set(keyHandle(key), "1", "NX", "EX", expireSecs);
// };
RedisCallback<Boolean> callback = (connection) -> {
return connection.set(keyHandle(key).getBytes(Charset.forName("UTF-8")), UUID.randomUUID().toString().getBytes(Charset.forName("UTF-8")), Expiration.seconds(TimeUnit.SECONDS.toSeconds(expireSecs)), RedisStringCommands.SetOption.SET_IF_ABSENT);
};
return (Boolean)stringRedisTemplate.execute(callback);
}
private String getSet(final String key, final String value) {
return stringRedisTemplate.opsForValue().getAndSet(keyHandle(key), value);
}
/**
* @Description: lock 即时锁 强制过期时间 缺点是会有过期时间内一直持有锁的隐患
*
* @param lockKey :
* @param timeout :
* @return: boolean
* @auther: wanglei
* @date: 2019/1/11 上午12:41
*/
public boolean lock(String lockKey,int timeout) throws InterruptedException {
if (0 == timeout) {
timeout = timeoutMsecs;
}
try {
if (this.setNX(lockKey, timeout)) {
// lock acquired
return true;
}
} catch (Exception e) {
log.error("lock::lockKey = [{}], timeout = [{}]",lockKey, timeout,e);
}
return false;
// while (timeout >= 0) {
// long expires = System.currentTimeMillis() + expireMsecs + 1;
// String expiresStr = String.valueOf(expires); // 锁到期时间
// if (this.setNX(lockKey, expiresStr)) {
// // lock acquired
// return true;
// }
//
// String currentValueStr = this.get(lockKey); // redis里的时间
// if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
// // 判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的
// // lock is expired
//
// String oldValueStr = this.getSet(lockKey, expiresStr);
// // 获取上一个锁到期时间，并设置现在的锁到期时间，
// if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
// // 防止误删（覆盖，因为key是相同的）了他人的锁——这里达不到效果，这里值会被覆盖，但是因为什么相差了很少的时间，所以可以接受
// // [分布式的情况下]:如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
// // lock acquired
// return true;
// }
// }
// timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
// /*
// * 延迟100 毫秒, 这里使用随机时间可能会好一点,可以防止饥饿进程的出现,即,当同时到达多个进程,
// * 只会有一个进程获得锁,其他的都用同样的频率进行尝试,后面有来了一些进行,也以同样的频率申请锁,这将可能导致前面来的锁得不到满足.
// * 使用随机的等待时间可以一定程度上保证公平性
// */
// Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);
//
// }
// return false;
}
/**
* Acqurired lock release.
*/
public boolean unlock(String lockKey) {
return stringRedisTemplate.delete(keyHandle(lockKey));
}
}
/* public static void main(String[] args) {
//连接本地的 Redis 服务
Jedis jedis = new Jedis("127.0.0.1");
System.out.println(jedis.set("1","1"));
System.out.println("连接成功");
System.out.println(TimeUnit.SECONDS.toSeconds(1));
}*/
}
|
package bootcamp.testng;
import org.testng.Assert;
import org.testng.annotations.Test;
public class AlwaysRun {
@Test
public void login() {
System.out.println("Perform login operation");
Assert.assertTrue(false);
}
@Test(alwaysRun = true)
public void verifyHomePage() {
System.out.println("Verify text on homepage");
}
}
|
package com.jim.multipos.ui.vendor_products_view.di;
import android.support.v7.app.AppCompatActivity;
import com.jim.multipos.config.scope.PerActivity;
import com.jim.multipos.config.scope.PerFragment;
import com.jim.multipos.core.BaseActivityModule;
import com.jim.multipos.ui.reports.order_history.OrderHistoryFragment;
import com.jim.multipos.ui.reports.order_history.OrderHistoryFragmentModule;
import com.jim.multipos.ui.reports.tills.TillsReportFragment;
import com.jim.multipos.ui.reports.tills.TillsReportFragmentModule;
import com.jim.multipos.ui.vendor_products_view.VendorProductsView;
import com.jim.multipos.ui.vendor_products_view.VendorProductsViewActivity;
import com.jim.multipos.ui.vendor_products_view.VendorProductsViewPresenter;
import com.jim.multipos.ui.vendor_products_view.VendorProductsViewPresenterImpl;
import com.jim.multipos.ui.vendor_products_view.fragments.VendorBelongProductsList;
import com.jim.multipos.ui.vendor_products_view.fragments.VendorDetailsFragment;
import com.jim.multipos.ui.vendor_products_view.presenter.VendorBelongProductListFragmentModule;
import com.jim.multipos.ui.vendor_products_view.presenter.VendorDetialsFragmentModule;
import dagger.Binds;
import dagger.Module;
import dagger.android.ContributesAndroidInjector;
/**
* Created by Portable-Acer on 17.11.2017.
*/
@Module(includes = BaseActivityModule.class)
public abstract class VendorProductsViewActivityModule {
@Binds
@PerActivity
abstract AppCompatActivity provideVendorProductsViewActivity(VendorProductsViewActivity activity);
@Binds
@PerActivity
abstract VendorProductsView provideVendorProductsView(VendorProductsViewActivity activity);
@Binds
@PerActivity
abstract VendorProductsViewPresenter provideVendorProductsViewPresenter(VendorProductsViewPresenterImpl presenter);
@PerFragment
@ContributesAndroidInjector(modules = VendorBelongProductListFragmentModule.class)
abstract VendorBelongProductsList provideVendorBelongProductsList();
@PerFragment
@ContributesAndroidInjector(modules = VendorDetialsFragmentModule.class)
abstract VendorDetailsFragment provideVendorDetailsFragment();
}
|
package com.设计模式.责任链模式;
/**
* 责任链模式
* Support为问题解决类，自己能解决的就解决了，否则丢给下一个人解决
* 接收问题--->解决前N个问题--->解决奇数问题--->解决前M个问题
* @author wicks
*
*/
public class Main {
public static void main(String[] args) {
Support alice = new NoSupport("Alice");
Support bob = new LimitSupport("Bob", 100);
Support elmo = new OddSupport("Elmo");
Support fred = new LimitSupport("Fred", 300);
// 形成职责链
alice.setNext(bob).setNext(elmo).setNext(fred);
// 制造各种问题
for (int i = 0; i < 500; i += 33) {
alice.support(new Trouble(i));
}
}
}
|
package com.jlgproject.model;
import com.jlgproject.model.newDebt.DebtRelation3Vo;
import com.jlgproject.model.newDebt.DebtRelation4Vo;
import java.io.Serializable;
import java.util.List;
/**
* @author 王锋 on 2017/6/6.
*/
public class DebtRelationVo implements Serializable {
private DebtRelation1Vo debtRelation1Vo;
private DebtRelation3Vo debtRelation3Vo;
private DebtRelation4Vo debtRelation4Vo;
public DebtRelationVo() {
}
public DebtRelationVo(DebtRelation1Vo debtRelation1Vo, DebtRelation3Vo debtRelation3Vo, DebtRelation4Vo debtRelation4Vo) {
this.debtRelation1Vo = debtRelation1Vo;
this.debtRelation3Vo = debtRelation3Vo;
this.debtRelation4Vo = debtRelation4Vo;
}
public DebtRelation1Vo getDebtRelation1Vo() {
return debtRelation1Vo;
}
public void setDebtRelation1Vo(DebtRelation1Vo debtRelation1Vo) {
this.debtRelation1Vo = debtRelation1Vo;
}
public DebtRelation3Vo getDebtRelation3Vo() {
return debtRelation3Vo;
}
public void setDebtRelation3Vo(DebtRelation3Vo debtRelation3Vo) {
this.debtRelation3Vo = debtRelation3Vo;
}
public DebtRelation4Vo getDebtRelation4Vo() {
return debtRelation4Vo;
}
public void setDebtRelation4Vo(DebtRelation4Vo debtRelation4Vo) {
this.debtRelation4Vo = debtRelation4Vo;
}
}
|
package com.dmitry.authentication.repositories;
import com.dmitry.authentication.models.entities.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends CrudRepository<User, Long> {
User findByEmail(String email);
User findByPassword(String token);
}
|
package com.bnr.android.criminalintent;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import android.app.Activity;
import android.app.Dialog;
import android.app.TimePickerDialog;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.DialogFragment;
import android.text.format.DateFormat;
import android.util.Log;
import android.view.View;
import android.widget.TimePicker;
public class TimePickerFragment extends DialogFragment implements TimePickerDialog.OnTimeSetListener {
public static final String TAG = "TimePickerFragment";
public static final String EXTRA_TIME = "com.bnr.android.criminalintent.time";
private Date mDate;
public static TimePickerFragment newInstance( Date date) {
Bundle args = new Bundle();
args.putSerializable(EXTRA_TIME, date);
TimePickerFragment fragment = new TimePickerFragment();
fragment.setArguments(args);
return fragment;
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
mDate = (Date)getArguments().getSerializable(EXTRA_TIME);
// Create a Calender to get the year, month and day.
Calendar calendar = Calendar.getInstance();
calendar.setTime( mDate);
int hour = calendar.get(Calendar.HOUR);
int min = calendar.get( Calendar.MINUTE);
View v = getActivity().getLayoutInflater().inflate(R.layout.dialog_time, null);
TimePicker timePicker = (TimePicker)v.findViewById(R.id.dialog_time_timePicker);
timePicker.setCurrentHour(hour);
timePicker.setCurrentMinute(min);
// Create a new instance of TimePickerDialog and return it
return new TimePickerDialog(getActivity(), this, hour, min,
DateFormat.is24HourFormat(getActivity()));
}
public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
Log.d(TAG, "TimePicker: Hour = " + hourOfDay + ", Minute = " + minute);
if (getTargetFragment() == null) {
return;
}
Calendar local = new GregorianCalendar();
local.setTime(this.mDate);
local.set( Calendar.HOUR, hourOfDay);
local.set( Calendar.MINUTE, minute);
mDate = local.getTime();
Intent i = new Intent();
i.putExtra(EXTRA_TIME, mDate);
Log.d(TAG, "sendResult: " + mDate.toString());
getTargetFragment().onActivityResult(getTargetRequestCode(), Activity.RESULT_OK, i);
}
}
|
package com.bw.movie.mvp.model.bean;
/**
* 作者：轻 on 2018/11/22 15:26
* <p>
* 邮箱：379996854@qq.com
*/
public class IndentBean {
/**
* orderId : 20180807084055347
* message : 下单成功
* status : 0000
*/
private String orderId;
private String message;
private String status;
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
|
package com.smxknife.graphql.ex2.component;
import com.smxknife.graphql.ex2.service.UserService;
import graphql.Scalars;
import graphql.schema.DataFetchingEnvironment;
import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLOutputType;
import graphql.schema.GraphQLSchema;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import static graphql.schema.GraphQLArgument.newArgument;
import static graphql.schema.GraphQLObjectType.newObject;
@Component
public class GraphQLProvider {
@Autowired
UserService userService;
private GraphQLOutputType user;
private GraphQLSchema schema;
public GraphQLProvider() {
user = newObject().name("user")
.field(GraphQLFieldDefinition.newFieldDefinition().name("id").type(Scalars.GraphQLInt))
.field(GraphQLFieldDefinition.newFieldDefinition().name("account").type(Scalars.GraphQLString))
.field(GraphQLFieldDefinition.newFieldDefinition().name("password").type(Scalars.GraphQLString))
.build();
schema = GraphQLSchema.newSchema()
.query(newObject()
.name("query")
.field(createUserField()))
.build();
}
/**
* query single author
* @return the single author's information
*/
private GraphQLFieldDefinition createUserField() {
return GraphQLFieldDefinition.newFieldDefinition()
.name("user")
.argument(newArgument().name("id").type(Scalars.GraphQLInt).build())
.type(user)
.dataFetcher((DataFetchingEnvironment environment) -> {
int id = environment.getArgument("id");
return this.userService.findById(id);
}).build();
}
public GraphQLSchema getSchema() {
return schema;
}
public void setSchema(GraphQLSchema schema) {
this.schema = schema;
}
public GraphQLOutputType getUser() {
return user;
}
public void setUser(GraphQLOutputType user) {
this.user = user;
}
}
|
package com.xiaolu.servlet;
import java.io.BufferedReader;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.xiaolu.dao.Tools;
import net.sf.json.JSONObject;
/**
* 功能：设置置顶留言
* @author Boy Baby
*
*/
@WebServlet("/TopMessagesServlet")
public class TopMessagesServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
public TopMessagesServlet() {
super();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//解决乱码
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");
//接受数据
StringBuffer sbJson = new StringBuffer();
String line = "";
try{
//读取网络传输过来的数据
BufferedReader br = request.getReader();
//遍历数据并拼接
while((line = br.readLine())!= null){
//如果读到数据,把他添加到字符流中
sbJson.append(line);
}
}catch (Exception e) {
e.printStackTrace();
}
System.out.println("client json data =" + sbJson);
// 功能:把读取到的数据封装 JSON
System.out.println("JSON = "+ sbJson.toString());
JSONObject jsonobject = JSONObject.fromObject(sbJson.toString());
String id = jsonobject.getString("id");//用户id
System.out.println("置顶留言id:"+ id);
String type = jsonobject.getString("type");//置顶留言标识
if(type.equals("1")){
String updatesql = "update messages set istop = 1 where p_id = "+id+"";
int count = Tools.executeUpdate(updatesql);
if(count > 0){
JSONObject jsonObject1=new JSONObject();
jsonObject1.put("result", "1");
jsonObject1.put("msg", "置顶成功");
String string = jsonObject1.toString();
System.out.println(string);
response.getWriter().write(string);
}else{
JSONObject jsonObject2=new JSONObject();
jsonObject2.put("result", "0");
jsonObject2.put("msg", "置顶失败");
String string2=jsonObject2.toString();
response.getWriter().write(string2);
}
}else{
String updatesql = "update messages set istop = 0 where p_id = "+id+"";
int count = Tools.executeUpdate(updatesql);
if(count > 0){
JSONObject jsonObject1=new JSONObject();
jsonObject1.put("result", "1");
jsonObject1.put("msg", "置顶成功");
String string = jsonObject1.toString();
System.out.println(string);
response.getWriter().write(string);
}else{
JSONObject jsonObject2=new JSONObject();
jsonObject2.put("result", "0");
jsonObject2.put("msg", "置顶失败");
String string2=jsonObject2.toString();
response.getWriter().write(string2);
}
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
}
|
package oop.snakegame.cells;
import oop.snakegame.Field;
import oop.snakegame.IVisitor;
import oop.snakegame.Level;
import oop.snakegame.primitives.Location;
public class TemporaryBonus extends ActiveBonus {
private int startTime;
private int timeToLive;
public TemporaryBonus(Location location, int timeToLive, int cost) {
super(location, cost);
startTime = timeToLive;
this.timeToLive = timeToLive;
}
public int getTimeToLive() { return timeToLive; }
@Override
public void UpdateGameState(Field field) {
timeToLive--;
if (timeToLive == 0) {
field.removeCell(this);
regenerate(field);
timeToLive = startTime;
}
}
@Override
public void regenerate(Field field) {
int time = field.random.nextInt(20) + 5;
field.addCell(new TemporaryBonus(field.getFreeRandomLocation(), time, cost));
}
@Override
public void accept(IVisitor visitor) { visitor.visit(this); }
}
|
package com.estilox.application.security;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.authentication.dao.AbstractUserDetailsAuthenticationProvider;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import com.estilox.application.model.JwtAuthenticationToken;
@Component
public class JwtAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider{
@Autowired
private JwtValidator validator;
@Override
public boolean supports(Class<?> aClass) {
return (JwtAuthenticationToken.class.isAssignableFrom(aClass));
}
@Override
protected void additionalAuthenticationChecks(UserDetails arg0, UsernamePasswordAuthenticationToken arg1)
throws AuthenticationException {
}
@Override
protected UserDetails retrieveUser(String userName, UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken)
throws AuthenticationException {
JwtAuthenticationToken jwtAuthenticationToken = (JwtAuthenticationToken)usernamePasswordAuthenticationToken;
String token = jwtAuthenticationToken.getToken();
JwtUser jwtUser = validator.validate(token);
if(jwtUser == null) {
throw new RuntimeException("JWT token is InCorrect..");
}
List<GrantedAuthority> grantedAuthorities = AuthorityUtils.commaSeparatedStringToAuthorityList(
jwtUser.getRole());
return new JwtUserDetails(jwtUser.getId(),jwtUser.getEmailId(),token,grantedAuthorities);
}
}
|
package com.shubh.javaworld;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class RoundSum {
public List<Integer> roundSum(List<Double> nums) {
List<Integer> roundedNum = new ArrayList<Integer>();
Map<Integer, Double> numMap = new HashMap<>();
int i = 0;
int sum = 0;
double sumDouble = 0;
for (double num : nums) {
int x = (int) Math.floor(num);
double diff = num - x;
sum += x;
sumDouble += num;
numMap.put(i, diff);
roundedNum.add(x);
i++;
}
int diff = (int) Math.round(sumDouble) - sum;
if (diff == 0) {
return roundedNum;
}
List<Entry<Integer, Double>> mapList = new ArrayList<Entry<Integer, Double>>(numMap.entrySet());
Collections.sort(mapList, (Comparator<Entry<Integer, Double>>) (a, b) -> b.getValue().compareTo(a.getValue()));
for (int j = 0; j < mapList.size() && diff > 0; j++) {
Entry<Integer, Double> e = mapList.get(j);
roundedNum.set(e.getKey(), roundedNum.get(e.getKey()) + 1);
diff--;
}
System.out.println("Rounded sum: " + Math.round(sumDouble));
return roundedNum;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Double> nums = new ArrayList<Double>();
nums.add(10.45);
nums.add(5.49);
nums.add(2.89);
nums.add(1.119);
RoundSum r = new RoundSum();
System.out.println(r.roundSum(nums));
}
}
|
package com.vilio.bps.commonMapper.pojo;
import java.io.Serializable;
import java.util.*;
import java.text.SimpleDateFormat;
import java.text.ParseException;
/**
* @实体名称 询价上载材料表
* @数表名称 BPS_INQUIRY_MATERIAL
* @开发日期 2017-06-12
* @技术服务 www.fwjava.com
*/
public class BpsInquiryMaterial implements Serializable {
/**
* (必填项)(主键ID)
*/
private Integer id = null;
/**
*
*/
private String code = null;
/**
* bps_user_inquiry表中serial_no
*/
private String serialNo = null;
/**
* 材料类型
*/
private String materialTypeCode = null;
/**
* 上载材料文件号(文件关联系统返回唯一编号)
*/
private String fileNo = null;
/**
* 上载文件名
*/
private String fileName = null;
/**
*
*/
private Date dateCreated = null;
/**
* 排序
*/
private String orderBy = null;
/*
*--------------------------------------------------
* Getter方法区
*--------------------------------------------------
*/
/**
* (必填项)(主键ID)
*/
public Integer getId() {
return id;
}
/**
*
*/
public String getCode() {
return trim(code);
}
/**
* bps_user_inquiry表中serial_no
*/
public String getSerialNo() {
return trim(serialNo);
}
/**
* 材料类型
*/
public String getMaterialTypeCode() {
return trim(materialTypeCode);
}
/**
* 上载材料文件号(文件关联系统返回唯一编号)
*/
public String getFileNo() {
return trim(fileNo);
}
/**
* 上载文件名
*/
public String getFileName() {
return trim(fileName);
}
/**
*
*/
public Date getDateCreated() {
return dateCreated;
}
/**
* 排序
*/
public String getOrderBy() {
return trim(orderBy);
}
/*
*--------------------------------------------------
* Setter方法区
*--------------------------------------------------
*/
/**
* (必填项)(主键ID)
*/
public void setId(Integer id) {
this.id = id;
}
/**
*
*/
public void setCode(String code) {
this.code = code;
}
/**
* bps_user_inquiry表中serial_no
*/
public void setSerialNo(String serialNo) {
this.serialNo = serialNo;
}
/**
* 材料类型
*/
public void setMaterialTypeCode(String materialTypeCode) {
this.materialTypeCode = materialTypeCode;
}
/**
* 上载材料文件号(文件关联系统返回唯一编号)
*/
public void setFileNo(String fileNo) {
this.fileNo = fileNo;
}
/**
* 上载文件名
*/
public void setFileName(String fileName) {
this.fileName = fileName;
}
/**
*
*/
public void setDateCreated(Date dateCreated) {
this.dateCreated = dateCreated;
}
/**
* 排序
*/
public void setOrderBy(String orderBy) {
this.orderBy = orderBy;
}
/*
*--------------------------------------------------
* 常用自定义字段
*--------------------------------------------------
*/
/**
* (格式化)
*/
public String getDateCreatedChar() {
return getDate(dateCreated);
}
public void setDateCreatedChar(String dateCreatedChar) {
this.dateCreated = getDate(dateCreatedChar);
}
/**
* (格式化)
*/
public String getDateCreatedCharAll() {
return getDateTime(dateCreated);
}
public void setDateCreatedCharAll(String dateCreatedCharAll) {
this.dateCreated = getDate(dateCreatedCharAll);
}
/*
*--------------------------------------------------
* 应用小方法
*--------------------------------------------------
*/
/**
* serialVersionUID
*/
private static final long serialVersionUID = 1L;
public String trim(String input)
{
return input==null?null:input.trim();
}
public String getDate(Date date)
{
if( null == date ) return "";
return new SimpleDateFormat("yyyy-MM-dd").format(date);
}
public String getDateTime(Date date)
{
if( null == date ) return "";
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
}
public Date getDate(String date)
{
if( null == date || date.trim().isEmpty() ) return null;
date = date.trim();
Date result = null;
try {
if( date.length() >= 19 )
{
result = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(date);
}
else if( date.length() == 10 )
{
result = new SimpleDateFormat("yyyy-MM-dd").parse(date);
}
}
catch (ParseException e)
{
}
return result;
}
}
/**
------------------------------------------------------
Copy专用区
------------------------------------------------------
------------------------------------------------------------------------------------------------------------
Setter方法
------------------------------------------------------------------------------------------------------------
// 询价上载材料表
BpsInquiryMaterial bpsInquiryMaterial = new BpsInquiryMaterial();
// (必填项)(主键ID)
bpsInquiryMaterial.setId( );
//
bpsInquiryMaterial.setCode( );
// bps_user_inquiry表中serial_no
bpsInquiryMaterial.setSerialNo( );
// 材料类型
bpsInquiryMaterial.setMaterialTypeCode( );
// 上载材料文件号(文件关联系统返回唯一编号)
bpsInquiryMaterial.setFileNo( );
// 上载文件名
bpsInquiryMaterial.setFileName( );
//
bpsInquiryMaterial.setDateCreated( );
//------ 自定义部分 ------
// (格式化)
bpsInquiryMaterial.setDateCreatedChar( );
------------------------------------------------------------------------------------------------------------
Getter方法
------------------------------------------------------------------------------------------------------------
// 询价上载材料表
BpsInquiryMaterial bpsInquiryMaterial = new BpsInquiryMaterial();
// (必填项)(主键ID)
bpsInquiryMaterial.getId();
//
bpsInquiryMaterial.getCode();
// bps_user_inquiry表中serial_no
bpsInquiryMaterial.getSerialNo();
// 材料类型
bpsInquiryMaterial.getMaterialTypeCode();
// 上载材料文件号(文件关联系统返回唯一编号)
bpsInquiryMaterial.getFileNo();
// 上载文件名
bpsInquiryMaterial.getFileName();
//
bpsInquiryMaterial.getDateCreated();
//------ 自定义部分 ------
// (格式化)
bpsInquiryMaterial.getDateCreatedChar();
------------------------------------------------------------------------------------------------------------
Getter Setter方法
------------------------------------------------------------------------------------------------------------
// 询价上载材料表
BpsInquiryMaterial bpsInquiryMaterial = new BpsInquiryMaterial();
// (必填项)(主键ID)
bpsInquiryMaterial.setId( bpsInquiryMaterial2.getId() );
//
bpsInquiryMaterial.setCode( bpsInquiryMaterial2.getCode() );
// bps_user_inquiry表中serial_no
bpsInquiryMaterial.setSerialNo( bpsInquiryMaterial2.getSerialNo() );
// 材料类型
bpsInquiryMaterial.setMaterialTypeCode( bpsInquiryMaterial2.getMaterialTypeCode() );
// 上载材料文件号(文件关联系统返回唯一编号)
bpsInquiryMaterial.setFileNo( bpsInquiryMaterial2.getFileNo() );
// 上载文件名
bpsInquiryMaterial.setFileName( bpsInquiryMaterial2.getFileName() );
//
bpsInquiryMaterial.setDateCreated( bpsInquiryMaterial2.getDateCreated() );
//------ 自定义部分 ------
// (格式化)
bpsInquiryMaterial.setDateCreatedChar( bpsInquiryMaterial2.getDateCreatedChar() );
------------------------------------------------------------------------------------------------------------
HTML标签区
------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------
属性区
------------------------------------------------------------------------------------------------------------
<!-- -->
<input name="id" value="" type="text" maxlength="36"/>
<!-- -->
<input name="code" value="" type="text" maxlength="36"/>
<!-- bps_user_inquiry表中serial_no -->
<input name="serialNo" value="" type="text" maxlength="36"/>
<!-- 材料类型 -->
<input name="materialTypeCode" value="" type="text" maxlength="36"/>
<!-- 上载材料文件号(文件关联系统返回唯一编号) -->
<input name="fileNo" value="" type="text" maxlength="36"/>
<!-- 上载文件名 -->
<input name="fileName" value="" type="text" maxlength="100"/>
<!-- -->
<input name="dateCreated" value="" type="text"/>
------------------------------------------------------------------------------------------------------------
表名 + 属性区
------------------------------------------------------------------------------------------------------------
<!-- -->
<input name="bpsInquiryMaterial.id" value="" type="text" maxlength="36"/>
<!-- -->
<input name="bpsInquiryMaterial.code" value="" type="text" maxlength="36"/>
<!-- bps_user_inquiry表中serial_no -->
<input name="bpsInquiryMaterial.serialNo" value="" type="text" maxlength="36"/>
<!-- 材料类型 -->
<input name="bpsInquiryMaterial.materialTypeCode" value="" type="text" maxlength="36"/>
<!-- 上载材料文件号(文件关联系统返回唯一编号) -->
<input name="bpsInquiryMaterial.fileNo" value="" type="text" maxlength="36"/>
<!-- 上载文件名 -->
<input name="bpsInquiryMaterial.fileName" value="" type="text" maxlength="100"/>
<!-- -->
<input name="bpsInquiryMaterial.dateCreated" value="" type="text"/>
------------------------------------------------------------------------------------------------------------
ID + 属性区
------------------------------------------------------------------------------------------------------------
<!-- -->
<input id="BIM_ID" name="id" value="" type="text" maxlength="36"/>
<!-- -->
<input id="BIM_CODE" name="code" value="" type="text" maxlength="36"/>
<!-- bps_user_inquiry表中serial_no -->
<input id="BIM_SERIAL_NO" name="serialNo" value="" type="text" maxlength="36"/>
<!-- 材料类型 -->
<input id="BIM_MATERIAL_TYPE_CODE" name="materialTypeCode" value="" type="text" maxlength="36"/>
<!-- 上载材料文件号(文件关联系统返回唯一编号) -->
<input id="BIM_FILE_NO" name="fileNo" value="" type="text" maxlength="36"/>
<!-- 上载文件名 -->
<input id="BIM_FILE_NAME" name="fileName" value="" type="text" maxlength="100"/>
<!-- -->
<input id="BIM_DATE_CREATED" name="dateCreated" value="" type="text"/>
------------------------------------------------------------------------------------------------------------
ID + 表名 + 属性区
------------------------------------------------------------------------------------------------------------
<!-- -->
<input id="BIM_ID" name="bpsInquiryMaterial.id" value="" type="text" maxlength="36"/>
<!-- -->
<input id="BIM_CODE" name="bpsInquiryMaterial.code" value="" type="text" maxlength="36"/>
<!-- bps_user_inquiry表中serial_no -->
<input id="BIM_SERIAL_NO" name="bpsInquiryMaterial.serialNo" value="" type="text" maxlength="36"/>
<!-- 材料类型 -->
<input id="BIM_MATERIAL_TYPE_CODE" name="bpsInquiryMaterial.materialTypeCode" value="" type="text" maxlength="36"/>
<!-- 上载材料文件号(文件关联系统返回唯一编号) -->
<input id="BIM_FILE_NO" name="bpsInquiryMaterial.fileNo" value="" type="text" maxlength="36"/>
<!-- 上载文件名 -->
<input id="BIM_FILE_NAME" name="bpsInquiryMaterial.fileName" value="" type="text" maxlength="100"/>
<!-- -->
<input id="BIM_DATE_CREATED" name="bpsInquiryMaterial.dateCreated" value="" type="text"/>
--------------------------------------------------------
*/
|
package com.tencent.mm.plugin.gallery.ui;
import android.view.View;
import android.view.View.OnClickListener;
import com.tencent.mm.R;
class ImagePreviewUI$22 implements OnClickListener {
final /* synthetic */ ImagePreviewUI jEa;
ImagePreviewUI$22(ImagePreviewUI imagePreviewUI) {
this.jEa = imagePreviewUI;
}
public final void onClick(View view) {
ImagePreviewUI.b(this.jEa, !ImagePreviewUI.b(this.jEa));
if (ImagePreviewUI.b(this.jEa)) {
ImagePreviewUI.c(this.jEa).setImageResource(R.k.radio_on);
if (ImagePreviewUI.d(this.jEa).size() == 0) {
ImagePreviewUI.e(this.jEa).performClick();
}
} else {
ImagePreviewUI.c(this.jEa).setImageResource(R.k.radio_off);
}
ImagePreviewUI.f(this.jEa).setText(this.jEa.mController.tml.getString(R.l.gallery_pic_orignal) + ImagePreviewUI.aRY());
ImagePreviewUI.a(this.jEa, ImagePreviewUI.g(this.jEa).intValue());
}
}
|
/*
* @project: (Sh)ower (R)econstructing (A)pplication for (M)obile (P)hones
* @version: ShRAMP v0.0
*
* @objective: To detect extensive air shower radiation using smartphones
* for the scientific study of ultra-high energy cosmic rays
*
* @institution: University of California, Irvine
* @department: Physics and Astronomy
*
* @author: Eric Albin
* @email: Eric.K.Albin@gmail.com
*
* @updated: 3 May 2019
*/
package sci.crayfis.shramp.camera2.requests;
import android.annotation.TargetApi;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraMetadata;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.params.ColorSpaceTransform;
import android.hardware.camera2.params.RggbChannelVector;
import android.support.annotation.NonNull;
import android.util.Log;
import java.util.LinkedHashMap;
import java.util.List;
import sci.crayfis.shramp.GlobalSettings;
import sci.crayfis.shramp.MasterController;
import sci.crayfis.shramp.camera2.CameraController;
import sci.crayfis.shramp.camera2.util.Parameter;
import sci.crayfis.shramp.camera2.util.ParameterFormatter;
/**
* Configuration class for default CaptureRequest creation, the parameters set here include:
* COLOR_CORRECTION_ABERRATION_MODE
* COLOR_CORRECTION_GAINS
* COLOR_CORRECTION_MODE
* COLOR_CORRECTION_TRANSFORM
*/
@TargetApi(21)
abstract class step03_Color_ extends step02_Black_ {
// Protected Overriding Instance Methods
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
// makeDefault..................................................................................
/**
* Creating a default CaptureRequest, setting COLOR_.* parameters
* @param builder CaptureRequest.Builder in progress
* @param characteristicsMap Parameter map of characteristics
* @param captureRequestMap Parameter map of capture request settings
*/
@SuppressWarnings("unchecked")
@Override
protected void makeDefault(@NonNull CaptureRequest.Builder builder,
@NonNull LinkedHashMap<CameraCharacteristics.Key, Parameter> characteristicsMap,
@NonNull LinkedHashMap<CaptureRequest.Key, Parameter> captureRequestMap) {
super.makeDefault(builder, characteristicsMap, captureRequestMap);
Log.e(" Color_", "setting default Color_ requests");
List<CaptureRequest.Key<?>> supportedKeys;
supportedKeys = CameraController.getAvailableCaptureRequestKeys();
if (supportedKeys == null) {
// TODO: error
Log.e(Thread.currentThread().getName(), "Supported keys cannot be null");
MasterController.quitSafely();
return;
}
//==========================================================================================
{
CaptureRequest.Key<Integer> rKey;
Parameter<Integer> setting;
String name;
rKey = CaptureRequest.COLOR_CORRECTION_ABERRATION_MODE;/////////////////////////////////
name = rKey.getName();
if (supportedKeys.contains(rKey)) {
CameraCharacteristics.Key<int[]> cKey;
Parameter<Integer> property;
cKey = CameraCharacteristics.COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES;
property = characteristicsMap.get(cKey);
if (property == null) {
// TODO: error
Log.e(Thread.currentThread().getName(), "Color correction modes cannot be null");
MasterController.quitSafely();
return;
}
setting = new Parameter<>(name, property.getValue(), property.getUnits(),
property.getFormatter());
builder.set(rKey, setting.getValue());
}
else {
setting = new Parameter<>(name);
setting.setValueString("NOT SUPPORTED");
}
captureRequestMap.put(rKey, setting);
}
//==========================================================================================
{
CaptureRequest.Key<RggbChannelVector> rKey;
Parameter<RggbChannelVector> setting;
ParameterFormatter<RggbChannelVector> formatter;
String name;
RggbChannelVector value;
String units;
rKey = CaptureRequest.COLOR_CORRECTION_GAINS;//////////////////////////////////////////
name = rKey.getName();
value = new RggbChannelVector(1, 1, 1, 1);
units = "unitless gain factor";
if (supportedKeys.contains(rKey)) {
formatter = new ParameterFormatter<RggbChannelVector>() {
@NonNull
@Override
public String formatValue(@NonNull RggbChannelVector value) {
return value.toString();
}
};
setting = new Parameter<>(name, value, units, formatter);
builder.set(rKey, value);
}
else {
setting = new Parameter<>(name);
setting.setValueString("NOT SUPPORTED");
}
captureRequestMap.put(rKey, setting);
}
//==========================================================================================
{
CaptureRequest.Key<Integer> rKey;
ParameterFormatter<Integer> formatter;
Parameter<Integer> setting;
String name;
Integer value;
String valueString;
rKey = CaptureRequest.COLOR_CORRECTION_MODE;////////////////////////////////////////////
name = rKey.getName();
if (supportedKeys.contains(rKey)) {
Parameter<Integer> mode;
mode = captureRequestMap.get(CaptureRequest.CONTROL_AWB_MODE);
if (mode == null) {
// TODO: error
Log.e(Thread.currentThread().getName(), "AWB mode cannot be null");
MasterController.quitSafely();
return;
}
if (mode.toString().contains("DISABLED")) {
Integer TRANSFORM_MATRIX = CameraMetadata.COLOR_CORRECTION_MODE_TRANSFORM_MATRIX;
//Integer FAST = CameraMetadata.COLOR_CORRECTION_MODE_FAST;
//Integer HIGH_QUALITY = CameraMetadata.COLOR_CORRECTION_MODE_HIGH_QUALITY;
value = TRANSFORM_MATRIX;
valueString = "TRANSFORM_MATRIX (PREFERRED)";
formatter = new ParameterFormatter<Integer>(valueString) {
@NonNull
@Override
public String formatValue(@NonNull Integer value) {
return getValueString();
}
};
setting = new Parameter<>(name, value, null, formatter);
builder.set(rKey, setting.getValue());
}
else {
setting = new Parameter<>(name);
setting.setValueString("DISABLED (FALLBACK)");
}
}
else {
setting = new Parameter<>(name);
setting.setValueString("NOT SUPPORTED");
}
captureRequestMap.put(rKey, setting);
}
//==========================================================================================
{
CaptureRequest.Key<ColorSpaceTransform> key;
Parameter<ColorSpaceTransform> setting;
ParameterFormatter<ColorSpaceTransform> formatter;
String name;
ColorSpaceTransform value;
String valueString;
key = CaptureRequest.COLOR_CORRECTION_TRANSFORM;//////////////////////////////////////
name = key.getName();
value = new ColorSpaceTransform(new int[]{
1, 1, 0, 1, 0, 1, // 1/1 , 0/1 , 0/1 = 1 0 0
0, 1, 1, 1, 0, 1, // 0/1 , 1/1 , 0/1 = 0 1 0
0, 1, 0, 1, 1, 1 // 0/1 , 0/1 , 1/1 = 0 0 1
});
valueString = "(1 0 0),(0 1 0),(0 0 1)";
if (supportedKeys.contains(key)) {
Parameter<Integer> mode;
mode = captureRequestMap.get(CaptureRequest.COLOR_CORRECTION_MODE);
if (mode == null) {
// TODO: error
Log.e(Thread.currentThread().getName(), "Color correction mode cannot be null");
MasterController.quitSafely();
return;
}
if (mode.toString().contains("DISABLED")) {
setting = new Parameter<>(name);
setting.setValueString("DISABLED (FALLBACK)");
}
else {
formatter = new ParameterFormatter<ColorSpaceTransform>(valueString) {
@NonNull
@Override
public String formatValue(@NonNull ColorSpaceTransform value) {
return getValueString();
}
};
setting = new Parameter<>(name, value, null, formatter);
builder.set(key, value);
}
captureRequestMap.put(key, setting);
}
}
//==========================================================================================
}
}
|
package controler;
public class gestionUtilisateur {
}
|
package piefarmer.immunology.item;
import org.lwjgl.opengl.GL11;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import piefarmer.immunology.model.ModelGlider;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.inventory.GuiContainerCreative;
import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.IItemRenderer;
@SideOnly(Side.CLIENT)
public class ItemHangGliderRenderer implements IItemRenderer{
ModelGlider model = new ModelGlider();
public static final ResourceLocation RESOURCE_GLIDER_TEXTURE = new ResourceLocation("immunology:textures/model/glider.png");
private static TextureManager textureManager;
@Override
public boolean handleRenderType(ItemStack item, ItemRenderType var2) {
return true;
}
@Override
public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item,
ItemRendererHelper helper) {
return false;
}
@Override
public void renderItem(ItemRenderType type, ItemStack item, Object... var3) {
textureManager = Minecraft.getMinecraft().func_110434_K();
textureManager.func_110577_a(RESOURCE_GLIDER_TEXTURE);
if(type == ItemRenderType.EQUIPPED)
{
if(var3.length > 1)
{
GL11.glPushMatrix();
if (var3[1] != null && var3[1] instanceof EntityPlayer)
{
float var5 = 0.5F;
GL11.glTranslatef(0.6F, 0.2F, 0.3F);
GL11.glScalef(var5, var5, var5);
GL11.glRotatef(190.0F, 0.0F, 0.0F, 1.0F);
GL11.glRotatef(100.0F, 0.0F, 1.0F, 0.0F);
GL11.glRotatef(-5.0F, 1.0F, 0.0F, 0.0F);
}
this.model.render((Entity)var3[1], 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0625F);
GL11.glPopMatrix();
}
}
else if(type == ItemRenderType.INVENTORY)
{
GL11.glPushMatrix();
GL11.glTranslatef(5.5F, 10.5F, 0.5F);
GL11.glScalef(6F, 6F, 6F);
GL11.glRotatef(0.0F, 0.0F, 0.0F, 1.0F);
GL11.glRotatef(120.0F, 0.0F, 1.0F, 0.0F);
GL11.glRotatef(-25.0F, 1.0F, 0.0F, 0.0F);
this.model.renderAll();
GL11.glPopMatrix();
}
}
}
|
package arrayJava;
// How to print element in array
public class ArrayElement {
public static void main(String[] args) {
int a[] = new int [2];
a[0] =10;
a[1] = 20;
for (int b : a) // for each loop
{
System.out.println("Element= "+b);
}
}
}
|
package jp.co.tau.web7.admin.supplier.dao.mappers;
import static org.assertj.core.api.Assertions.fail;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import jp.co.tau.web7.admin.supplier.mappers.TVsmSupplierMngNoMapper;
@RunWith(SpringRunner.class)
@SpringBootTest
public class TVsmSupplierMngNoMapperTest extends MapperBaseTest {
@Autowired
TVsmSupplierMngNoMapper tVsmSupplierMngNoMapper;
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 1 error )
* </p>
*/
@Test
public void testFindInfoWinBid_001() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 2 error )
* </p>
*/
@Test
public void testFindInfoWinBid_002() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 3 error )
* </p>
*/
@Test
public void testFindInfoWinBid_003() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 4 error )
* </p>
*/
@Test
public void testFindInfoWinBid_004() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 5 error )
* </p>
*/
@Test
public void testFindInfoWinBid_005() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 6 error )
* </p>
*/
@Test
public void testFindInfoWinBid_006() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 7 error )
* </p>
*/
@Test
public void testFindInfoWinBid_007() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 8 error )
* </p>
*/
@Test
public void testFindInfoWinBid_008() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 9 error )
* </p>
*/
@Test
public void testFindInfoWinBid_009() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 10 error )
* </p>
*/
@Test
public void testFindInfoWinBid_010() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 11 error )
* </p>
*/
@Test
public void testFindInfoWinBid_011() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join 12 error )
* </p>
*/
@Test
public void testFindInfoWinBid_012() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, null));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：0 record(join ok, param@stkNo=2 )
* </p>
*/
@Test
public void testFindInfoWinBid_013() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, expectedResult));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
/**
* {@link TTauAucInfoMapper#findInfoWinBid(String}のテスト
* <p>
* Pattern：1 record(join ok, param@stkNo=1 )
* </p>
*/
@Test
public void testFindInfoWinBid_014() {
try {
// 対象メソッドを呼び出し、テストを行う
Object actualResult = tVsmSupplierMngNoMapper.findInfoWinBid((String) parameter);
assert(compareObj(actualResult, expectedResult));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage(), e);
}
}
}
|
/*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you 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 eu.intrasoft.cordova.filesdownloader;
/**
* Download item info
*/
class DownloadItemInfo {
private long id;
private String uri;
private int status;
private int reason;
private long bytesDownloaded;
private long bytesTotal;
public DownloadItemInfo(long id, String uri) {
this.id = id;
this.uri = uri;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getUri() {
return uri;
}
public void setUri(String uri) {
this.uri = uri;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public int getReason() {
return reason;
}
public void setReason(int reason) {
this.reason = reason;
}
public long getBytesDownloaded() {
return bytesDownloaded;
}
public void setBytesDownloaded(long bytesDownloaded) {
this.bytesDownloaded = bytesDownloaded;
}
public long getBytesTotal() {
return bytesTotal;
}
public void setBytesTotal(long bytesTotal) {
this.bytesTotal = bytesTotal;
}
/**
* Get download progress percentage
*
* @return Percentage
*/
public int getDownloadProgress() {
if (this.getBytesTotal() > 0) {
return (int)Math.ceil((double)this.getBytesDownloaded() / (double)this.getBytesTotal() * 100);
}
return 0;
}
}
|
/**
*
* 项目地址：
* https://github.com/apache/groovy
* 官方文档：
* http://www.groovy-lang.org/
*
*/
|
package org.example.model;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.chart.PieChart;
import org.example.DB.DBConnection;
import javax.sql.RowSet;
import javax.xml.transform.Result;
import java.sql.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class UserDaoImpl implements UserDao {
private RowSet rowSet=null;
private Connection conn=null;
private Statement statement = null;
private PreparedStatement preparedStatement = null;
public UserDaoImpl() throws SQLException {
conn = DBConnection.getConnection();
statement = conn.createStatement();
}
@Override
public List<User> getAllUsers() {
List<User> users= new ArrayList<>();
try {
String sql = "select * from users";
ResultSet resultSet = statement.executeQuery(sql);
while(resultSet.next()){
User user = extractUser(resultSet);
users.add(user);
}
} catch (SQLException e) {
e.printStackTrace();
}
return users;
}
@Override
public User getUser(int id) {
User user = null;
try {
String sql = "select * from users where id = " + id;
ResultSet resultSet = statement.executeQuery(sql);
if(resultSet.next()){
user = extractUser(resultSet);
}
} catch (SQLException e) {
e.printStackTrace();
}
return user;
}
@Override
public boolean updateUser(int id, User user) {
try{
// You Must Add All Updated and Not Updated User Info In User Object
String sql = "update users set" +
" id = ?" +
" ,phone_number = ?" +
" ,name = ?" +
" ,email = ?" +
" ,picture_path = ?" +
" ,password = ?" +
" ,gender = ?" +
" ,country = ?" +
" ,bio = ?" +
" ,date_of_birth = ?" +
" ,verified = ?" +
" ,chatbotoption = ?" +
" ,status_id = ?" +
" where id = " + id;
preparedStatement = conn.prepareStatement(sql);
injectUser(user);
int affectedRows = preparedStatement.executeUpdate();
if(affectedRows > 0)
return true;
return false;
}catch(SQLException e){
e.printStackTrace();
}
return false;
}
@Override
public boolean deleteUser(int id) {
try {
String sql = "delete from users where id = " + id;
int affectedRows = statement.executeUpdate(sql);
if(affectedRows > 0){
return true;
}
return false;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
@Override
public boolean addUser(User user) {
if(getUser(user.getId()) == null){
try {
String sql = "insert into users values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
preparedStatement = conn.prepareStatement(sql);
injectUser(user);
int affectedRows = preparedStatement.executeUpdate();
if(affectedRows > 0)
return true;
return false;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
return false;
}
@Override
public List<User> getFriendList(User user){
List<User> friends = new ArrayList<>();
try {
String sql = "select second_member from contacts where first_member = ? " +
" union select first_member from contacts where second_number = ?";
preparedStatement = conn.prepareStatement(sql);
preparedStatement.setInt(1, user.getId());
preparedStatement.setInt(2, user.getId());
ResultSet resultSet = preparedStatement.executeQuery();
while(resultSet.next()){
friends.add(getUser(resultSet.getInt(1)));
}
} catch (SQLException e) {
e.printStackTrace();
}
return friends;
}
@Override
public ObservableList<PieChart.Data> getUsersByGender() {
int females =0;
int males = 0;
ResultSet resultSet ;
ObservableList<PieChart.Data> genderData = FXCollections.observableArrayList();
String femaleSql = "select count(gender) from contacts where gender ="+ Gender.Female+")";
String maleSql = "select count(gender) from contacts where gender ="+ Gender.Male+")";
try {
resultSet = statement.executeQuery(femaleSql);
females = resultSet.getInt(1);
resultSet = statement.executeQuery(maleSql);
males = resultSet.getInt(1);
} catch (SQLException e) {
e.printStackTrace();
}
PieChart.Data malesData = new PieChart.Data("Males",males);
PieChart.Data feMalesData = new PieChart.Data("Females",females);
genderData.addAll(malesData,feMalesData);
return genderData;
}
@Override
public ObservableList<PieChart.Data> getUsersByCountry() {
return null;
// need to ask for number of countries and what are they ?
}
@Override
public ObservableList<PieChart.Data> getUsersByStatus() {
int online =0;
int offline = 0;
ResultSet resultSet ;
ObservableList<PieChart.Data> statusData = FXCollections.observableArrayList();
String onlineSql = "select count(status) from contacts where status ="+ UserStatus.ONLINE+")";
String offlineSql = "select count(status) from contacts where status <>"+ UserStatus.ONLINE+")";
try {
resultSet = statement.executeQuery(onlineSql);
online = resultSet.getInt(1);
resultSet = statement.executeQuery(offlineSql);
offline = resultSet.getInt(1);
} catch (SQLException e) {
e.printStackTrace();
}
PieChart.Data onlineData = new PieChart.Data("ONline",online);
PieChart.Data offlineData = new PieChart.Data("OFFline",offline);
statusData.addAll(onlineData,offlineData);
return statusData;
}
private User extractUser(ResultSet resultSet){
try{
User user = new User();
user.setId(resultSet.getInt(1));
user.setPhone(resultSet.getString(2));
user.setName(resultSet.getString(3));
user.setEmail(resultSet.getString(4));
user.setImageURL(resultSet.getString(5));
user.setPassword(resultSet.getString(6));
Gender gender = Gender.Male;
switch (resultSet.getString(7)){
case "Female":
gender = Gender.Female;
break;
}
user.setGender(gender);
user.setCountry(resultSet.getString(8));
user.setBio(resultSet.getString(9));
user.setDateOfBirth(resultSet.getDate(10));
user.setVerified(resultSet.getBoolean(11));
user.setChatbotOption(resultSet.getBoolean(12));
UserStatus status = UserStatus.OFFLINE;
switch ((resultSet.getInt(13))){
case 1:
status = UserStatus.ONLINE;
break;
case 2:
status = UserStatus.BUSY;
break;
}
user.setStatus(status);
return user;
}catch (SQLException e){
return null;
}
}
private void injectUser(User user){
try{
preparedStatement.setInt(1, user.getId());
preparedStatement.setString(2, user.getPhone());
preparedStatement.setString(3, user.getName());
preparedStatement.setString(4, user.getEmail());
preparedStatement.setString(5, user.getImageURL());
preparedStatement.setString(6, user.getPassword());
Gender gender = user.getGender();
String genderString = "Male";
if(gender != null){
switch (gender){
case Female:
genderString = "Female";
break;
}
}
preparedStatement.setString(7, genderString);
preparedStatement.setString(8, user.getCountry());
preparedStatement.setString(9, user.getBio());
// Convert Java.util.Date To Java.Sql.Date
// preparedStatement.setDate(10, java.sql.Date.from(user.getDateOfBirth().toInstant()));
preparedStatement.setDate(10, null);
preparedStatement.setBoolean(11, user.isVerified());
preparedStatement.setBoolean(12, user.isChatbotOption());
UserStatus status = user.getStatus();
int statusNumber = 0;
if(status != null){
switch (status){
case ONLINE:
statusNumber = 1;
break;
case BUSY:
statusNumber = 2;
break;
}
}
preparedStatement.setInt(13, statusNumber);
}catch(SQLException e){
e.printStackTrace();
}
}
}
|
package Client;
import Shared.GameMap;
import Shared.Player;
import Shared.Territory;
import Utilities.ColorPrint;
public class GameClientViewer {
public void printMap(GameMap map, Player player, String style) {
for(var p: map.getPlayerMap().values()) {
if(p.getTerritories().isEmpty()) {
System.out.printf("%s player: (Lose)\n", p.getName());
System.out.print("-------------\n\n");
continue;
}
if(p.getName().equals(player.getName())) {
System.out.printf("%s player: (You)\n", player.getName());
}
else {
System.out.printf("%s player: \n", p.getName());
}
System.out.print("-------------\n");
printOwnedTerritory(p, style);
}
}
private void printOwnedTerritory(Player p, String style) {
if(style.equals("simple")) {
for (var t : p.getTerritories()) {
System.out.printf("%s (next to:", t.getName());
for (var tn : t.getNeighbors()) {
System.out.printf(" %s", tn.getName());
}
System.out.print(")\n");
}
System.out.println();
}
if(style.equals("order")) {
ColorPrint cp = new ColorPrint();
for (var t : p.getTerritories()) {
ColorPrint.Color color = ColorPrint.Color.WHITE;
if(t.isAttackLock()) {
color = ColorPrint.Color.RED;
System.out.print("|" + cp.setColor("A", color) + "|" + cp.setColor("M",color) + "|");
}
else if(t.isMoveLock()) {
color = ColorPrint.Color.SKYBLUE;
System.out.print("|" +cp.setColor("M",color) + "|");
}
System.out.print(cp.setColor(getTerritoryOrderName(t),color) + "[" + t.getUnits() + "] (next to:");
for (var tn : t.getNeighbors()) {
System.out.printf(" %s[%d]", getTerritoryOrderName(tn), tn.getUnits());
}
System.out.print(")\n");
}
System.out.println();
}
}
private String getTerritoryOrderName(Territory t) {
int lenAlias = t.getAliasName().length();
return "(" + t.getAliasName() + ")" + t.getName().substring(lenAlias);
}
}
|
package com.tradeshift.todo.dao;
import java.sql.SQLException;
import com.tradeshift.todo.entity.User;
public interface UserDAO {
public User getUser(String userGuid) throws SQLException;
}
|
/*
* UniTime 3.4 - 3.5 (University Timetabling Application)
* Copyright (C) 2013, UniTime LLC, and individual contributors
* as indicated by the @authors tag.
*
* This program 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.
*
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
package org.unitime.timetable.server.script;
import java.util.Date;
import java.util.List;
import org.unitime.timetable.gwt.command.client.GwtRpcResponseList;
import org.unitime.timetable.gwt.command.server.GwtRpcImplementation;
import org.unitime.timetable.gwt.command.server.GwtRpcImplements;
import org.unitime.timetable.gwt.shared.ScriptInterface.GetQueueTableRpcRequest;
import org.unitime.timetable.gwt.shared.ScriptInterface.QueueItemInterface;
import org.unitime.timetable.security.SessionContext;
import org.unitime.timetable.util.queue.QueueItem;
import org.unitime.timetable.util.queue.QueueProcessor;
/**
* @author Tomas Muller
*/
@GwtRpcImplements(GetQueueTableRpcRequest.class)
public class GetQueueTableBackend implements GwtRpcImplementation<GetQueueTableRpcRequest, GwtRpcResponseList<QueueItemInterface>>{
@Override
public GwtRpcResponseList<QueueItemInterface> execute(GetQueueTableRpcRequest request, SessionContext context) {
if (request.getDeleteId() != null)
QueueProcessor.getInstance().remove(request.getDeleteId());
List<QueueItem> queue = QueueProcessor.getInstance().getItems(null, null, "Script");
GwtRpcResponseList<QueueItemInterface> table = new GwtRpcResponseList<QueueItemInterface>();
Date now = new Date();
long timeToShow = 1000 * 60 * 60;
for (QueueItem item: queue) {
if (item.finished() != null && now.getTime() - item.finished().getTime() > timeToShow) continue;
table.add(convert(item, context));
}
return table;
}
public static QueueItemInterface convert(QueueItem item, SessionContext context) {
QueueItemInterface q = new QueueItemInterface();
q.setId(item.getId());
q.setName(item.name());
q.setStatus(item.status());
q.setProgress(item.progress() <= 0.0 || item.progress() >= 1.0 ? "" : String.valueOf(Math.round(100 * item.progress())) + "%");
q.setOwner(item.getOwnerName());
q.setSession(item.getSession() == null ? "None" : item.getSession().getLabel());
q.setCreated(item.created());
q.setStarted(item.started());
q.setFinished(item.finished());
if (item.finished() != null && item.hasOutput())
q.setOutput(item.output().getName());
q.setLog(item.log());
q.setCanDelete(context.getUser().getExternalUserId().equals(item.getOwnerId()) && (item.started() == null || item.finished() != null));
if (item instanceof ScriptExecution)
q.setExecutionRequest(((ScriptExecution)item).getRequest());
return q;
}
}
|
package rjm.romek.awscourse.repository;
import java.util.List;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import rjm.romek.awscourse.model.Chapter;
import rjm.romek.awscourse.model.Task;
@Repository
public interface TaskRepository extends CrudRepository<Task, Long> {
List<Task> findByChapter(Chapter chapter);
}
|
package org.dota.steam.service;
import org.dota.model.InventoryItem;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {
DotaInventoryItemsService.class
})
@TestPropertySource(properties = "steam.api.dev_key=test_dev_key")
public class DotaInventoryItemsServiceTest {
@Autowired
private DotaInventoryItemsService itemsService;
@Test
public void testNoSuchItem() {
Integer nonExistId = 1_000_000;
Optional<InventoryItem> actual = itemsService.getItemById(nonExistId);
Optional<InventoryItem> expected = Optional.empty();
assertThat(actual, equalTo(expected));
}
@Test
public void testGetDagonItemById() {
Integer dagonId = 104;
Optional<InventoryItem> dagon = itemsService.getItemById(dagonId);
Optional<InventoryItem> expectedItem = Optional.of(new InventoryItem(
dagonId,
"Dagon",
2720,
false,
false,
false
));
assertThat(dagon, equalTo(expectedItem));
}
@Test
public void testGetAllItems() {
List<InventoryItem> items = itemsService.getItems();
Integer expectedNumberOfItems = 259;
assertThat(items.size(), equalTo(expectedNumberOfItems));
}
}
|
package com.tencent.mm.plugin.shake.c.b;
import android.view.View;
import android.view.View.OnClickListener;
import com.tencent.mm.R;
import com.tencent.mm.plugin.shake.c.b.a.a;
import com.tencent.mm.sdk.platformtools.x;
class a$2 implements OnClickListener {
final /* synthetic */ a mYd;
a$2(a aVar) {
this.mYd = aVar;
}
public final void onClick(View view) {
if (view.getId() == R.h.card_close_img) {
this.mYd.dismiss();
if (a.a(this.mYd) != null) {
a.a(this.mYd).buR();
}
x.i("MicroMsg.ShakeCardDialog", "close ShakeCardDialog");
} else if (view.getId() != R.h.card_accept_btn) {
} else {
if (a.b(this.mYd) == a.mYf) {
a.a(this.mYd, a.mYg);
a.b(this.mYd, 0);
a.c(this.mYd);
a.d(this.mYd);
} else if (a.b(this.mYd) == a.mYg) {
} else {
if (a.b(this.mYd) == a.mYi) {
a.d(this.mYd);
} else if (a.b(this.mYd) == a.mYh) {
com.tencent.mm.sdk.b.a.sFg.b(a.e(this.mYd));
a.f(this.mYd);
}
}
}
}
}
|
package es.coritel.codington.festival.services;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import es.coritel.codington.festival.domain.Event;
import es.coritel.codington.festival.interfaces.daos.IEventDAO;
import es.coritel.codington.festival.interfaces.services.IEventService;
@Service
public class EventServiceImpl implements IEventService {
@Autowired
private IEventDAO eventDAO;
@Override
@Transactional(readOnly=true)
public List<Event> getAllEvents(){
// TODO: completar código
return eventDAO.showAllEvents();
}
}
|
package com.jokeit.repository;
import com.jokeit.domain.Feedback;
public interface FeedbackRepository {
void save(Feedback feedback, Integer jokeId);
}
|
package com.xiaoxin.urlshorter;
import com.xiaoxin.urlshorter.utils.IdWorker;
import com.xiaoxin.urlshorter.utils.NumericConvertUtils;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class UrlshorterDemoApplication {
public static void main(String[] args) {
SpringApplication.run(UrlshorterDemoApplication.class, args);
}
@Bean
public IdWorker idWorker() {
return new IdWorker();
}
// @Bean
// public NumericConvertUtils numericConvertUtils() {
// return new NumericConvertUtils();
// }
}
|
package com.microsilver.mrcard.basicservice.dao;
import com.microsilver.mrcard.basicservice.model.FxFile;
import com.microsilver.mrcard.basicservice.model.FxFileExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface FxFileMapper {
int countByExample(FxFileExample example);
int deleteByExample(FxFileExample example);
int deleteByPrimaryKey(Integer id);
int insert(FxFile record);
int insertSelective(FxFile record);
List<FxFile> selectByExample(FxFileExample example);
FxFile selectByPrimaryKey(Integer id);
int updateByExampleSelective(@Param("record") FxFile record, @Param("example") FxFileExample example);
int updateByExample(@Param("record") FxFile record, @Param("example") FxFileExample example);
int updateByPrimaryKeySelective(FxFile record);
int updateByPrimaryKey(FxFile record);
}
|
package com.podarbetweenus.Activities;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.GridView;
import android.widget.LinearLayout;
import android.widget.Spinner;
import android.widget.TextView;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.podarbetweenus.BetweenUsConstant.Constant;
import com.podarbetweenus.Entity.LoginDetails;
import com.podarbetweenus.R;
import com.podarbetweenus.Services.DataFetchService;
import org.json.JSONObject;
import java.text.DateFormatSymbols;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import static android.content.Context.MODE_PRIVATE;
/**
* Created by Gayatri on 31/01/2017.
*/
public class ShowCalendarrActivity extends LinearLayout
{
public static String ShowCalenderData_Method_name = "AttenCalenderData";
public static Context mycontext;
DataFetchService dft;
LoginDetails login_details;
ProgressDialog progressDialog;
String clt_id="", brd_name="", class_id = "", Acy_year = "";
String strYear="";
int year_index;
public HashMap yearData = new HashMap();
public HashMap monthData = new HashMap();
ArrayList<String> yearList = new ArrayList<>();
ArrayList<String> monthList = new ArrayList<>();
ArrayList<String> AttendenceEnteredDates = new ArrayList<>();
ArrayList<String> HolidayDates = new ArrayList<>();
private static int month_number;
// for logging
private static final String LOGTAG = "Calendar View";
// how many days to show, defaults to six weeks, 42 days
private static final int DAYS_COUNT = 42;
// default date format
private static final String DATE_FORMAT = "MMM yyyy";
// date format
private String dateFormat;
// current displayed month
private Calendar currentDate = Calendar.getInstance();
//event handling
private EventHandler eventHandler = null;
// internal components
private LinearLayout header;
private Spinner monthSpinner;
private Spinner yearSpinner;
private TextView txtDate;
private GridView grid;
private EditText ed_select_month,ed_select_year;
// seasons' rainbow
int[] rainbow = new int[] {
R.color.summer,
R.color.fall,
R.color.winter,
R.color.spring
};
// month-season association (northern hemisphere, sorry australia :)
int[] monthSeason = new int[] {2, 2, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2};
public ShowCalendarrActivity(Context context, AttributeSet attrs)
{
super(context, attrs);
initControl(context, attrs);
mycontext = context;
// Log.d("<< Called", "Constructor 1");
}
/* public ShowCalendarrActivity(Context context, AttributeSet attrs, int defStyleAttr)
{
super(context, attrs, defStyleAttr);
initControl(context, attrs);
Log.d("<< Called", "Constructor 2");
}*/
// Preferences are set inside TeacherAttendenceActivity
public void getSharedPrefData(Context context){
SharedPreferences pref = context.getSharedPreferences("AttendencePref", MODE_PRIVATE);
clt_id = pref.getString("client_id",null);
class_id = pref.getString("class_id",null);
brd_name = pref.getString("board_name",null);
Acy_year = pref.getString("academic_year",null);
}
/**
* Load control xml layout
*/
private void initControl(Context context, AttributeSet attrs)
{
mycontext = context;
LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
inflater.inflate(R.layout.calendar_layout, this);
loadDateFormat(attrs);
assignUiElements();
dft = new DataFetchService(context);
login_details = new LoginDetails();
progressDialog = Constant.getProgressDialog(context);
assignClickHandlers();
addListenerOnMonthSpinnerItemSelection();
addListenerOnYearSpinnerItemSelection();
getSharedPrefData(context);
CallWSToShowCalenderData(clt_id, class_id, Acy_year,brd_name);
}
private void CallWSToShowCalenderData(String clt_id, String class_id, String Acy_year, String brd_name) {
if(dft.isInternetOn()==true) {
if (!progressDialog.isShowing()) {
progressDialog.show();
}
}
else{
progressDialog.dismiss();
}
dft.getCalenderData(clt_id, class_id, Acy_year, brd_name, ShowCalenderData_Method_name, Request.Method.POST,
new Response.Listener<JSONObject>() {
@Override
public void onResponse(JSONObject response) {
if (progressDialog.isShowing()) {
progressDialog.dismiss();
}
try {
login_details = (LoginDetails) dft.GetResponseObject(response, LoginDetails.class);
Log.d("<<ShowCalender RSP", response.toString());
if (login_details.Status.equalsIgnoreCase("1")) {
//success
//Log.d("<<ShowCalenderActivity", response.toString());
addDataToSpinner();
} else if (login_details.Status.equalsIgnoreCase("0")) {
// Log.d("<<ShowCalenderActivity", "Request Failed");
//failed
}
} catch (Exception e) {
e.printStackTrace();
}
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
//Show error or whatever...
// Log.d("TeacherEntrMesgActivity", "ERROR.._---" + error.getCause());
}
});
}
private void loadDateFormat(AttributeSet attrs)
{
TypedArray ta = getContext().obtainStyledAttributes(attrs, R.styleable.CustomCheckedTextView);
try
{
// try to load provided date format, and fallback to default otherwise
dateFormat = ta.getString(R.styleable.CustomCheckedTextView_dateFormat);
if (dateFormat == null)
dateFormat = DATE_FORMAT;
}
finally
{
ta.recycle();
}
}
private void assignUiElements()
{
// layout is inflated, assign local variables to components
monthSpinner= (Spinner) findViewById(R.id.spinner);
yearSpinner= (Spinner) findViewById(R.id.spinner3) ;
header = (LinearLayout)findViewById(R.id.calendar_header);
grid = (GridView)findViewById(R.id.calendar_grid);
}
// Getting years and adding them to year spinner
public void addDataToSpinner(){
Log.d("<<Call","addDataToSpinner");
//adding all years to year list
for(int i=0; i<login_details.YearMonthResult.size(); i++){
strYear = login_details.YearMonthResult.get(i).strYear;
yearList.add(strYear);
yearData.put(strYear,i); //{2016,0}, {2017,1}
Log.d("<<yearData", strYear + ":" + String.valueOf(i));
}
// reversing yearlist to get current year as default in year spineer
Collections.reverse(yearList);
// populate year Year spinner with yearList data
addYearsToSpinner();
}
//Adding items to months spinner
public void addMonthsToSpinner(){
int month = currentDate.get(Calendar.MONTH);
String default_month = getMonth(month);
ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(getContext(), android.R.layout.simple_spinner_item, monthList );
dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
monthSpinner.setAdapter(dataAdapter);
updateCalendar();
}
public String getMonth(int month) {
return new DateFormatSymbols().getMonths()[month];
}
public void addYearsToSpinner(){
ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(getContext(), android.R.layout.simple_spinner_item, yearList);
dataAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
yearSpinner.setAdapter(dataAdapter);
addMonthsToSpinner();
}
public void addListenerOnMonthSpinnerItemSelection(){
Log.d("<<Called","addListenerOnMonthSpinnerItemSelection()");
monthSpinner = (Spinner) findViewById(R.id.spinner);
monthSpinner.setOnItemSelectedListener(new MonthOnItemSelectedListener());
}
public void addListenerOnYearSpinnerItemSelection(){
Log.d("<<Called","addListenerOnYearSpinnerItemSelection()");
yearSpinner = (Spinner) findViewById(R.id.spinner3);
yearSpinner.setOnItemSelectedListener(new YearOnItemSelectedListener());
}
public class MonthOnItemSelectedListener implements AdapterView.OnItemSelectedListener {
public void onItemSelected(AdapterView<?> parent, View view, int pos,long id) {
AttendenceEnteredDates.clear();
HolidayDates.clear();
Log.d("<<Called","MonthOnItemSelectedListener ");
String month_selected = parent.getItemAtPosition(pos).toString();
//Log.d("<<Selected month", month_selected);
// Getting index to traverse holidays, attendence entered dates
int month_index = Integer.parseInt(monthData.get(month_selected).toString());
//Log.d("<<month index", String.valueOf(month_index));
//Log.d("<<year index", String.valueOf(year_index));
//Log.d("<<year at index", String.valueOf(yearData.get(year_index)));
int list_size1 = login_details.YearMonthResult.get(year_index).AttendMonthResult.get(month_index).AttendEnteredResult.size();
Log.d("<<Attendence list size", String.valueOf(list_size1));
int list_size2 = login_details.YearMonthResult.get(year_index).AttendMonthResult.get(month_index).AttendHolidayResult.size();
Log.d("<<Holiday list size", String.valueOf(list_size2));
// Adding attendence entered date to list to highlight them in calender
for (int i = 0; i< login_details.YearMonthResult.get(year_index).AttendMonthResult.get(month_index).AttendEnteredResult.size();i++){
String attendenceEnteredDate = login_details.YearMonthResult.get(year_index).AttendMonthResult.get(month_index).AttendEnteredResult.get(i).Entereddate;
//Log.d("<<Att Date retrieved", attendenceEnteredDate);
if(String.valueOf(attendenceEnteredDate.charAt(0)).equalsIgnoreCase("0")){
attendenceEnteredDate = String.valueOf(attendenceEnteredDate.charAt(1));
//Log.d("<<Att Date Modified", attendenceEnteredDate);
}
AttendenceEnteredDates.add(attendenceEnteredDate);
}
// Adding holiday date to list to highlight them in calender
for (int i = 0; i< login_details.YearMonthResult.get(year_index).AttendMonthResult.get(month_index).AttendHolidayResult.size();i++){
String holidayDate = login_details.YearMonthResult.get(year_index).AttendMonthResult.get(month_index).AttendHolidayResult.get(i).Holidaydate;
if(String.valueOf(holidayDate.charAt(0)).equalsIgnoreCase("0")){
holidayDate = String.valueOf(holidayDate.charAt(1));
// Log.d("<<Holiday Date Modified", holidayDate);
}
HolidayDates.add(holidayDate);
}
Date date = null;
try {
date = new SimpleDateFormat("MMM", Locale.ENGLISH).parse(month_selected);
} catch (ParseException e) {
e.printStackTrace();
}
Calendar cal = Calendar.getInstance();
cal.setTime(date);
month_number = cal.get(Calendar.MONTH);
Log.d("<<month_number ",String.valueOf(month_number));
currentDate.set(Calendar.MONTH,month_number);
updateCalendar();
/*Toast.makeText(parent.getContext(),
"OnItemSelectedListener : " + parent.getItemAtPosition(pos).toString(),
Toast.LENGTH_SHORT).show();*/
}
@Override
public void onNothingSelected(AdapterView<?> arg0) {
// TODO Auto-generated method stub
}
}
public class YearOnItemSelectedListener implements AdapterView.OnItemSelectedListener{
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
monthList.clear();
// Log.d("<<Called","YearOnItemSelectedListener ");
String year_selected = parent.getItemAtPosition(position).toString();
year_index = Integer.parseInt(yearData.get(year_selected).toString());
for (int i =0;i<login_details.YearMonthResult.get(year_index).AttendMonthResult.size();i++){
String month = login_details.YearMonthResult.get(year_index).AttendMonthResult.get(i).StrMonth;
// Log.d("<<MonthListElement",month);
monthList.add(month);
monthData.put(month, i);
}
int year_selected2 = Integer.parseInt(parent.getItemAtPosition(position).toString());
currentDate.set(Calendar.YEAR,year_selected2);
addMonthsToSpinner();
updateCalendar();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
}
}
private void assignClickHandlers()
{
// long-pressing a day
grid.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener()
{
@Override
public boolean onItemLongClick(AdapterView<?> view, View cell, int position, long id)
{
// handle long-press
if (eventHandler == null)
return false;
eventHandler.onDayLongPress((Date)view.getItemAtPosition(position));
return true;
}
});
grid.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Date dateClicked = (Date)parent.getItemAtPosition(position);
// Log.d("<<calender date", String.valueOf(dateClicked.getDate()));
// Log.d("<<calender month", String.valueOf(dateClicked.getMonth()));
// Log.d("<<calender year", String.valueOf(dateClicked.getYear()));
Date today = new Date();
int day = today.getDate();
int month = today.getMonth();
int year = today.getYear();
SimpleDateFormat sdf_ = new SimpleDateFormat("EEEE");
String dayName = sdf_.format(dateClicked);
//Log.d("<<Date Today",String.valueOf(day)+"/"+String.valueOf(month)+"/"+String.valueOf(year));
//Log.d("<<Date OnClicked",String.valueOf(dateClicked.getDate())+"/"+String.valueOf(dateClicked.getMonth())+"/"+String.valueOf(dateClicked.getYear()));
//Log.d("<<Holiday check", String.valueOf(HolidayDates.contains(String.valueOf(dateClicked.getDate()).trim())==true));
if(dayName.equalsIgnoreCase("SUNDAY")){
// its sunday so do nothing
}
else if(HolidayDates.contains(String.valueOf(dateClicked.getDate()))==true){
Constant.showOkPopup(mycontext, "Not allowed to add attendance for Holiday dates!", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss();
}
});
}
else if (dateClicked.getDate() > day && dateClicked.getMonth() >= month && dateClicked.getYear() >= year)
{
Constant.showOkPopup(mycontext, "Not allowed to add attendance for future dates!", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss();
}
});
}
else if (dateClicked.getMonth() != month_number){
// date does not belong to current selected month so Do nothing
}
else {
Intent i = new Intent(view.getContext(), TeacherAddAttendenceActivity.class);
i.putExtra("date", String.valueOf(dateClicked.getDate()));
i.putExtra("month", String.valueOf(dateClicked.getMonth()));
i.putExtra("year", String.valueOf(dateClicked.getYear()));
if(AttendenceEnteredDates.contains(String.valueOf(dateClicked.getDate()))){
i.putExtra("mode","update");
}
else{
i.putExtra("mode", "Insert");
}
view.getContext().startActivity(i);
}
}
});
}
/**
* Display dates correctly in grid
*/
public void updateCalendar()
{
updateCalendar(null);
}
/**
* Display dates correctly in grid
*/
public void updateCalendar(HashSet<Date> events)
{
ArrayList<Date> cells = new ArrayList<>();
Calendar calendar = (Calendar)currentDate.clone();
// determine the cell for current month's beginning
calendar.set(Calendar.DAY_OF_MONTH, 1);
int monthBeginningCell = calendar.get(Calendar.DAY_OF_WEEK) - 1;
// move calendar backwards to the beginning of the week
calendar.add(Calendar.DAY_OF_MONTH, -monthBeginningCell);
// fill cells
while (cells.size() < DAYS_COUNT)
{
cells.add(calendar.getTime());
calendar.add(Calendar.DAY_OF_MONTH, 1);
}
// update grid
grid.setAdapter(new CalendarAdapter(getContext(), cells, events));
// update title
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
// txtDate.setText(sdf.format(currentDate.getTime()));
// set header color according to current
int month = currentDate.get(Calendar.MONTH);
int season = monthSeason[month];
int color = rainbow[season];
header.setBackgroundColor(getResources().getColor(color));
}
private class CalendarAdapter extends ArrayAdapter<Date>
{
// days with events
private HashSet<Date> eventDays;
// for view inflation
private LayoutInflater inflater;
public CalendarAdapter(Context context, ArrayList<Date> days, HashSet<Date> eventDays)
{
super(context, R.layout.control_calendar_day, days);
this.eventDays = eventDays;
inflater = LayoutInflater.from(context);
}
@Override
public View getView(int position, View view, ViewGroup parent)
{
//Getting each date view item in calender
Date date = getItem(position);
int day = date.getDate();
int month = date.getMonth();
int year = date.getYear();
//Log.d("<<current day",String.valueOf(day));
//Log.d("<<current month",String.valueOf(month));
// Log.d("<<current year",String.valueOf(year));
SimpleDateFormat sdf_ = new SimpleDateFormat("EEEE");
String dayName = sdf_.format(date);
//Log.e("<<DATE",String.valueOf(day));
//Log.e("<<DAY",dayName);
// today
Date today = new Date();
// inflate item if it does not exist yet
if (view == null)
view = inflater.inflate(R.layout.control_calendar_day, parent, false);
TextView tv_cal_grid = (TextView)view.findViewById(R.id.tv_cal_grid);
// if this day has an event, specify event image
view.setBackgroundResource(0);
tv_cal_grid.setTextColor(Color.parseColor("#ff4040"));
for(int i=0;i<AttendenceEnteredDates.size();i++) {
String value1 = AttendenceEnteredDates.get(i);
// Log.d("<< value1",value1);
// Log.d("<< value2",String.valueOf(day));
if (String.valueOf(day).equalsIgnoreCase(value1) /*&& month == today.getMonth()*/) {
tv_cal_grid.setTextColor(Color.parseColor("#00ff00"));
Log.d("<< Attendence Color set",value1);
}
}
for(int i=0; i<HolidayDates.size();i++){
String value1 = HolidayDates.get(i);
Log.d("<<Holiday value",value1);
// Log.d("<< value2",String.valueOf(day));
if(String.valueOf(day).equalsIgnoreCase(value1) ){
tv_cal_grid.setTextColor(Color.parseColor("#800080"));
Log.d("<< Holiday Color set",value1);
}
}
/*for(int i=0;i<=dates.size();i++){
grid.getChildAt(i).setBackgroundColor(Color.BLUE);
// tv_cal_grid.setTextColor(getResources().getColor(R.color.green));
}*/
/* Log.d("<<today.getMonth()",String.valueOf(today.getMonth()));
Log.d("<<month", String.valueOf(month));*/
if (month != month_number /*|| year != today.getYear()*/)
{
/* Log.d("<< i today.getMonth()",String.valueOf(today.getMonth()));
Log.d("<< i month", String.valueOf(month));*/
// if this day is outside current month, grey it out
// ((TextView)view).setTextColor(getResources().getColor(R.color.greyed_out));
tv_cal_grid.setTextColor(getResources().getColor(R.color.greyed_out));
}
if (day == today.getDate() && month ==today.getMonth())
{
// if it is today, set it to blue/bold
// ((TextView)view).setTypeface(null, Typeface.BOLD);
((TextView)view).setTextColor(getResources().getColor(R.color.today));
tv_cal_grid.setTypeface(null, Typeface.BOLD);
tv_cal_grid.setTextColor(getResources().getColor(R.color.today));
}
if(dayName.equalsIgnoreCase("SUNDAY") /*&& month ==today.getMonth()*/){
// ((TextView)view).setTextColor(getResources().getColor(R.color.red));
tv_cal_grid.setTextColor(Color.parseColor("#ffa500"));
}
// set text
//((TextView)view).setText(String.valueOf(date.getDate()));
tv_cal_grid.setText(String.valueOf(date.getDate()));
List<Date> disable = new ArrayList<>();
Calendar cal = Calendar.getInstance();
cal.set(Calendar.DAY_OF_MONTH, 1);
int mon = cal.get(Calendar.MONTH);
do {
int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
if (dayOfWeek == Calendar.SUNDAY)
disable.add(cal.getTime());
cal.add(Calendar.DAY_OF_MONTH, 1);
} while (cal.get(Calendar.MONTH) == mon);
SimpleDateFormat fmt = new SimpleDateFormat("EEE M/d/yyyy");
Log.e("Size of disable",String.valueOf(disable.size()));
for(int i = 0;i<=disable.size();i++){
// ((TextView)view).setTextColor(getResources().getColor(R.color.red));
}
for (Date date1 : disable)
// System.out.println(fmt.format(date1));
Log.e("DATEEEE",fmt.format(date1));
// view.setBackgroundResource(R.color.red);
// grid.setBackgroundColor(Color.RED);
// grid.getChildAt(position).setBackgroundColor(Color.RED);
return view;
}
}
/**
* Assign event handler to be passed needed events
*/
public void setEventHandler(EventHandler eventHandler)
{
this.eventHandler = eventHandler;
}
/**
* This interface defines what events to be reported to
* the outside world
*/
public interface EventHandler
{
void onDayLongPress(Date date);
}
}
|
package com.hqhcn.android.entity;
import java.util.Date;
public class VehInspRecord {
private Long id;
private String jlcxh;
private String kcdddh;
private String hphm;
private String jlczt;
private String hpzl;
private String jklx;
private String kskm;
private Date sj;
private String msg;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getJlcxh() {
return jlcxh;
}
public void setJlcxh(String jlcxh) {
this.jlcxh = jlcxh == null ? null : jlcxh.trim();
}
public String getKcdddh() {
return kcdddh;
}
public void setKcdddh(String kcdddh) {
this.kcdddh = kcdddh == null ? null : kcdddh.trim();
}
public String getHphm() {
return hphm;
}
public void setHphm(String hphm) {
this.hphm = hphm == null ? null : hphm.trim();
}
public String getJlczt() {
return jlczt;
}
public void setJlczt(String jlczt) {
this.jlczt = jlczt == null ? null : jlczt.trim();
}
public String getHpzl() {
return hpzl;
}
public void setHpzl(String hpzl) {
this.hpzl = hpzl == null ? null : hpzl.trim();
}
public String getJklx() {
return jklx;
}
public void setJklx(String jklx) {
this.jklx = jklx == null ? null : jklx.trim();
}
public String getKskm() {
return kskm;
}
public void setKskm(String kskm) {
this.kskm = kskm == null ? null : kskm.trim();
}
public Date getSj() {
return sj;
}
public void setSj(Date sj) {
this.sj = sj;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg == null ? null : msg.trim();
}
}
|
/*!
* Copyright 2002 - 2017 Webdetails, a Pentaho company. All rights reserved.
*
* This software was developed by Webdetails and is provided under the terms
* of the Mozilla Public License, Version 2.0, or any later version. You may not use
* this file except in compliance with the license. If you need a copy of the license,
* please go to http://mozilla.org/MPL/2.0/. The Initial Developer is Webdetails.
*
* Software distributed under the Mozilla Public License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. Please refer to
* the license for the specific language governing your rights and limitations.
*/
package pt.webdetails.cdf.dd.model.meta.validation;
public final class ComponentTypeUndefinedPropertyError extends ComponentTypeError {
private final String _propertyName;
public ComponentTypeUndefinedPropertyError( String componentTypeLabel, String propertyName ) {
super( componentTypeLabel );
if ( propertyName == null ) {
throw new IllegalArgumentException( "propertyName" );
}
this._propertyName = propertyName;
}
public String getPropertyName() {
return this._propertyName;
}
@Override
public String toString() {
return "ComponentType '" + this._componentTypeLabel + "' refers an undefined property: '" + this._propertyName
+ "'.";
}
}
|
/**
* Created by daniellindeman on 10/18/15.
*/
public class AmortizedLoan extends Loan
{
public AmortizedLoan(String name, double rate, int years, double amount)
{
super(name, rate, years, amount);
}
public void calcMonthlyPayment ()
{
int lengthInMonths = length * 12;
double monthlyRate = interestRate / 12;
double n = Math.pow((1 + monthlyRate),(lengthInMonths));
monthlyPayment = principle * ((monthlyRate * n)/(n - 1));
}
public String toString()
{
return "Full Amortized Loan";
}
}
|
package it.bad_request.hackaton.certificami.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import it.bad_request.hackaton.certificami.entity.Certificazione;
public interface CertificazioneRepository extends JpaRepository<Certificazione, Long>{
}
|
package objects;
import enums.ObjectType;
public class EmptyObject extends GameObject {
public EmptyObject() {
super(ObjectType.EMPTY);
}
}
|
/**
@author Akshay Mattoo
*/
package NNClassifier.Distance;
import NNClassifier.*;
import NNClassifier.Distance.*;
import NNClassifier.VPTree.*;
import java.util.ArrayList;
/**
Implements DistanceFunction interface for Euclidean distance metric
*/
public class l2Distance implements DistanceFunction {
/**
Computes the Euclidean distance (l2 Distance) between two Image vectors
@param two Image objects
@return Euclidean distance between Image one and two
*/
public double distance (Image one, Image two)
{
double dist = 0.0;
if (one==null || two==null)
{
System.out.println("ERROR! Image was found to be null");
return dist;
}
ArrayList <Integer> p1 = one.getPixels();
ArrayList <Integer> p2 = two.getPixels();
if (p1.size() != p2.size())
{
System.out.println("ERROR! Images do not have equal number of pixels");
return dist;
}
for (int i=0; i<p1.size(); ++i)
{
double x1 = (double)(p1.get(i));
double x2 = (double)(p2.get(i));
double diff = x1-x2;
dist += (diff*diff);
}
dist = Math.sqrt(dist);
return dist;
}
}
|
package com.example.face_beautification;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.util.Log;
import org.opencv.android.Utils;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;
import java.util.ArrayList;
import java.util.List;
public class WhiteningTranslater extends Translater {
public WhiteningTranslater() {
super("Whitening", "美白", true, 0);
}
@Override
Bitmap render(PictureManager pictureManager, Bitmap bitmap) {
if (level > 0) {
int clen = bitmap.getWidth(), rlen = bitmap.getHeight();
int pixel;
int[] newPixels = new int[rlen * clen];
for (int i = 0; i < rlen; i++) {
for (int j = 0; j < clen; j++) {
pixel = bitmap.getPixel(j, i);
int r = Color.red(pixel);
int g = Color.green(pixel);
int b = Color.blue(pixel);
double brightness = 0.299 * r + 0.587 * g + 0.114 * b;
double brightnessIncre = (((Math.log((brightness / 255) * 0.02 * level + 1) / Math.log(0.02 * level + 1))) - brightness / 255) * 255;
r = r + (int) brightnessIncre > 255 ? 255 : r + (int) brightnessIncre;//R
g = g + (int) brightnessIncre > 255 ? 255 : g + (int) brightnessIncre;//G
b = b + (int) brightnessIncre > 255 ? 255 : b + (int) brightnessIncre;//B
newPixels[i * clen + j] = Color.rgb(r, g, b);
}
}
bitmap.setPixels(newPixels, 0, clen, 0, 0, clen, rlen);
return bitmap;
} else {
return bitmap;
}
}
}
|
package com.tencent.mm.app.plugin;
import android.os.Bundle;
import com.tencent.mm.app.plugin.URISpanHandlerSet.BaseUriSpanHandler;
import com.tencent.mm.app.plugin.URISpanHandlerSet.a;
import com.tencent.mm.model.q;
import com.tencent.mm.plugin.account.b;
import com.tencent.mm.pluginsdk.s;
import com.tencent.mm.pluginsdk.ui.applet.m;
import com.tencent.mm.pluginsdk.ui.d.g;
import com.tencent.mm.pluginsdk.ui.d.l;
import com.tencent.mm.sdk.platformtools.bi;
@a
class URISpanHandlerSet$PhoneEmailUriSpanHandler extends BaseUriSpanHandler {
final /* synthetic */ URISpanHandlerSet bAt;
URISpanHandlerSet$PhoneEmailUriSpanHandler(URISpanHandlerSet uRISpanHandlerSet) {
this.bAt = uRISpanHandlerSet;
super(uRISpanHandlerSet);
}
final m db(String str) {
return null;
}
final int[] vB() {
return new int[]{25, 24};
}
final boolean a(m mVar, g gVar) {
if (mVar.type == 25) {
String str = mVar.username;
Bundle bundle = new Bundle();
if (!(str == null || str.equals(q.GF()))) {
bundle.putString("Contact_User", str);
com.tencent.mm.plugin.account.friend.a.a pp = b.getAddrUploadStg().pp(str);
if (pp == null || bi.oW(pp.Xh())) {
str = null;
} else {
str = bi.oV(pp.Xp()).replace(" ", "");
}
bundle.putString("Contact_Mobile_MD5", str);
}
bundle.putInt("fromScene", 1);
l.a(URISpanHandlerSet.a(this.bAt), mVar.url, null, bundle);
return true;
}
if (mVar.type == 24) {
l.b(URISpanHandlerSet.a(this.bAt), mVar.url, null);
}
return false;
}
final boolean a(String str, boolean z, s sVar, Bundle bundle) {
return false;
}
}
|
/*
* [y] hybris Platform
*
* Copyright (c) 2018 SAP SE or an SAP affiliate company. All rights reserved.
*
* This software is the confidential and proprietary information of SAP
* ("Confidential Information"). You shall not disclose such Confidential
* Information and shall use it only in accordance with the terms of the
* license agreement you entered into with SAP.
*/
package de.hybris.platform.cmsfacades.pagetemplates;
import de.hybris.platform.cmsfacades.data.PageTemplateDTO;
import de.hybris.platform.cmsfacades.data.PageTemplateData;
import java.util.List;
/**
* Component facade interface which deals with methods related to page operations.
*/
public interface PageTemplateFacade
{
/**
* Retrieves the list of page templates fmatching the given filters
*
* @param pageTemplateDTO
* dto containing search restrictions
* @return a list of {@link PageTemplateData}
*/
List<PageTemplateData> findPageTemplates(PageTemplateDTO pageTemplateDTO);
}
|
package com.tt.miniapp.msg;
import android.os.SystemClock;
import android.text.TextUtils;
import com.tt.frontendapiinterface.a;
import com.tt.frontendapiinterface.b;
import com.tt.miniapp.AppbrandApplicationImpl;
import com.tt.miniapp.util.timeline.MpTimeLineReporter;
import com.tt.miniapphost.AppBrandLogger;
import com.tt.option.e.e;
import org.json.JSONObject;
public class ApiReportTimeLinePointsCtrl extends b {
public ApiReportTimeLinePointsCtrl(String paramString, int paramInt, e parame) {
super(paramString, paramInt, parame);
}
public void act() {
try {
boolean bool;
MpTimeLineReporter mpTimeLineReporter = (MpTimeLineReporter)AppbrandApplicationImpl.getInst().getService(MpTimeLineReporter.class);
JSONObject jSONObject = new JSONObject(this.mArgs);
String str = jSONObject.optString("points");
if (jSONObject.optInt("is_collect", 0) == 1) {
bool = true;
} else {
bool = false;
}
if (TextUtils.isEmpty(str) && !bool) {
callbackFail(a.b("points"));
return;
}
if (!TextUtils.isEmpty(str))
mpTimeLineReporter.sendPointsDirectly(str);
if (bool)
mpTimeLineReporter.sendJsEndCollectPoints();
mpTimeLineReporter.addPoint("verify_time", System.currentTimeMillis(), SystemClock.elapsedRealtime(), null);
callbackOk();
return;
} catch (Exception exception) {
AppBrandLogger.e("ApiReportTimeLinePointsCtrl", new Object[] { exception });
callbackFail(exception);
return;
}
}
public String getActionName() {
return "reportTimelinePoints";
}
}
/* Location: C:\Users\august\Desktop\tik\df_miniapp\classes.jar!\com\tt\miniapp\msg\ApiReportTimeLinePointsCtrl.class
* Java compiler version: 6 (50.0)
* JD-Core Version: 1.1.3
*/
|
import java.util.ArrayList;
import java.util.List;
/**
* Create new account and check the validation
*
* @author (your name here)
* @version (version number or date here)
*/
public class Customer
{
// instance variables - replace the example below with your own
public String name;
public String password;
public String level;
public String address;
public String paymentInfo;
public String email;
public List<Product> products = new ArrayList<Product>();
public Customer()
{
name="";
password="";
level="";
address="";
paymentInfo="";
email="";
}
public Customer(Account account)
{
name=account.verifyid;
}
public Customer(Customer customer)
{
this.name=customer.name;
this.password=customer.password;
this.level=customer.level;
this.address=customer.address;
this.paymentInfo=customer.paymentInfo;
this.email=customer.email;
}
public Customer(String name1, String password1, String level1, String address1, String paymentInfo1, String email1)
{
this.name=name;
this.password=password;
this.level=level;
this.address=address;
this.paymentInfo=paymentInfo;
this.email=email;
}
public boolean modify()
{
// put your code here
return true;
}
public List<Product> search()
{
// put your code here
return this.products;
}
}
|
package com.org.review;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ReviewMsApplication {
public static void main(String[] args) {
SpringApplication.run(ReviewMsApplication.class, args);
}
}
|
package com.singtel.nsb.mobile;
import org.apache.camel.opentracing.starter.CamelOpenTracing;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration;
import org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration;
import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
import org.springframework.kafka.annotation.EnableKafka;
@CamelOpenTracing
@SpringBootApplication(exclude = { MongoAutoConfiguration.class, MongoDataAutoConfiguration.class, KafkaAutoConfiguration.class})
@EnableKafka
public class NsbHttpListenerApplication {
public static void main(String[] args) {
SpringApplication.run(NsbHttpListenerApplication.class);
}
}
|
package com.tencent.matrix.resource.e;
import android.app.Activity;
import android.app.Application;
import android.app.Application.ActivityLifecycleCallbacks;
import android.content.Context;
import android.os.Bundle;
import android.os.Debug;
import com.tencent.matrix.resource.CanaryWorkerService;
import com.tencent.matrix.resource.analyzer.model.DestroyedActivityInfo;
import com.tencent.matrix.resource.c;
import java.io.File;
import java.lang.ref.WeakReference;
import java.util.Iterator;
import java.util.UUID;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicLong;
import org.json.JSONObject;
public final class b extends com.tencent.matrix.c.a {
final int brw;
public final com.tencent.matrix.resource.e.e.a bsA;
public final c bss;
public final e bst;
private final d bsu;
final c bsv;
final com.tencent.matrix.resource.e.c.a bsw;
final ConcurrentLinkedQueue<DestroyedActivityInfo> bsx;
final AtomicLong bsy;
public final ActivityLifecycleCallbacks bsz;
public static class a {
protected d az(Context context) {
return new d(context);
}
protected c a(Context context, d dVar) {
return new c(context, dVar);
}
protected com.tencent.matrix.resource.e.c.a a(final Context context, com.tencent.matrix.resource.b.a aVar) {
return new com.tencent.matrix.resource.e.c.a() {
public final void a(com.tencent.matrix.resource.analyzer.model.a aVar) {
CanaryWorkerService.a(context, aVar);
}
};
}
}
public b(Application application, final c cVar) {
this(application, cVar, new a() {
protected final d az(Context context) {
if (cVar.brq.brx) {
return super.az(context);
}
return null;
}
protected final c a(Context context, d dVar) {
if (cVar.brq.brx) {
return super.a(context, dVar);
}
return null;
}
protected final com.tencent.matrix.resource.e.c.a a(Context context, com.tencent.matrix.resource.b.a aVar) {
if (aVar.brx) {
return super.a(context, aVar);
}
return null;
}
});
}
private b(Application application, c cVar, a aVar) {
super(application, "memory", cVar);
this.bsz = new a() {
public final void onActivityCreated(Activity activity, Bundle bundle) {
b.this.bsy.incrementAndGet();
}
public final void onActivityDestroyed(Activity activity) {
b bVar = b.this;
String name = activity.getClass().getName();
if (bVar.cb(name)) {
com.tencent.matrix.d.b.d("Matrix.ActivityRefWatcher", "activity leak with name %s had published, just ignore", name);
return;
}
UUID randomUUID = UUID.randomUUID();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("MATRIX_RESCANARY_REFKEY_").append(name).append('_').append(Long.toHexString(randomUUID.getMostSignificantBits())).append(Long.toHexString(randomUUID.getLeastSignificantBits()));
bVar.bsx.add(new DestroyedActivityInfo(stringBuilder.toString(), activity, name, bVar.bsy.get()));
}
};
this.bsA = new com.tencent.matrix.resource.e.e.a() {
public final int tB() {
if (Debug.isDebuggerConnected()) {
com.tencent.matrix.d.b.w("Matrix.ActivityRefWatcher", "debugger is connected, to avoid fake result, detection was delayed.", new Object[0]);
return com.tencent.matrix.resource.e.e.a.a.bsQ;
} else if (b.this.bsx.isEmpty()) {
return com.tencent.matrix.resource.e.e.a.a.bsQ;
} else {
WeakReference weakReference = new WeakReference(new Object());
com.tencent.matrix.d.b.v("Matrix.ActivityRefWatcher", "triggering gc...", new Object[0]);
Runtime.getRuntime().gc();
Runtime.getRuntime().runFinalization();
com.tencent.matrix.d.b.v("Matrix.ActivityRefWatcher", "gc was triggered.", new Object[0]);
if (weakReference.get() != null) {
com.tencent.matrix.d.b.d("Matrix.ActivityRefWatcher", "system ignore our gc request, wait for next detection.", new Object[0]);
return com.tencent.matrix.resource.e.e.a.a.bsQ;
}
Iterator it = b.this.bsx.iterator();
while (it.hasNext()) {
DestroyedActivityInfo destroyedActivityInfo = (DestroyedActivityInfo) it.next();
if (b.this.cb(destroyedActivityInfo.mActivityName)) {
com.tencent.matrix.d.b.v("Matrix.ActivityRefWatcher", "activity with key [%s] was already published.", destroyedActivityInfo.mActivityName);
it.remove();
} else if (destroyedActivityInfo.mActivityRef.get() == null) {
com.tencent.matrix.d.b.v("Matrix.ActivityRefWatcher", "activity with key [%s] was already recycled.", destroyedActivityInfo.mKey);
it.remove();
} else {
destroyedActivityInfo.mDetectedCount++;
long j = b.this.bsy.get() - destroyedActivityInfo.mLastCreatedActivityCount;
if (destroyedActivityInfo.mDetectedCount < b.this.brw || j < 2) {
com.tencent.matrix.d.b.i("Matrix.ActivityRefWatcher", "activity with key [%s] should be recycled but actually still \nexists in %s times detection with %s created activities during destroy, wait for next detection to confirm.", destroyedActivityInfo.mKey, Integer.valueOf(destroyedActivityInfo.mDetectedCount), Long.valueOf(j));
} else {
com.tencent.matrix.d.b.i("Matrix.ActivityRefWatcher", "activity with key [%s] was suspected to be a leaked instance.", destroyedActivityInfo.mKey);
if (b.this.bsv != null) {
File tC = b.this.bsv.tC();
if (tC != null) {
b.this.ca(destroyedActivityInfo.mActivityName);
b.this.bsw.a(new com.tencent.matrix.resource.analyzer.model.a(tC, destroyedActivityInfo.mKey, destroyedActivityInfo.mActivityName));
it.remove();
} else {
com.tencent.matrix.d.b.i("Matrix.ActivityRefWatcher", "heap dump for further analyzing activity with key [%s] was failed, just ignore.", destroyedActivityInfo.mKey);
it.remove();
}
} else {
com.tencent.matrix.d.b.i("Matrix.ActivityRefWatcher", "lightweight mode, just report leaked activity name.", new Object[0]);
b.this.ca(destroyedActivityInfo.mActivityName);
if (b.this.bss != null) {
JSONObject jSONObject = new JSONObject();
try {
jSONObject.put("activity", destroyedActivityInfo.mActivityName);
} catch (Throwable e) {
com.tencent.matrix.d.b.printErrStackTrace("Matrix.ActivityRefWatcher", e, "unexpected exception.", new Object[0]);
}
b.this.bss.a(new com.tencent.matrix.c.b(jSONObject));
}
}
}
}
}
return com.tencent.matrix.resource.e.e.a.a.bsQ;
}
}
};
this.bss = cVar;
com.tencent.matrix.resource.b.a aVar2 = cVar.brq;
this.bst = new e(aVar2.brv, com.tencent.matrix.d.a.tJ());
this.brw = aVar2.brw;
this.bsu = aVar.az(application);
this.bsv = aVar.a((Context) application, this.bsu);
this.bsw = aVar.a((Context) application, aVar2);
this.bsx = new ConcurrentLinkedQueue();
this.bsy = new AtomicLong(0);
}
public final void tA() {
Application application = this.bss.application;
if (application != null) {
application.unregisterActivityLifecycleCallbacks(this.bsz);
e eVar = this.bst;
eVar.bsK.removeCallbacksAndMessages(null);
eVar.mMainHandler.removeCallbacksAndMessages(null);
this.bsx.clear();
this.bsy.set(0);
}
}
}
|
package com.finix.manager.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import com.finix.bean.GovernmentUserBean;
import com.finix.bean.ScreenDetailBean;
import com.finix.bean.TemplateBean;
import com.finix.bean.TheaterDetailBean;
import com.finix.dao.IGovernmentUserDao;
import com.finix.dao.impl.GovernmentUserDaoImpl;
import com.finix.manager.IGovernmentUserManager;
public class GovernmentUserManagerImpl implements IGovernmentUserManager{
IGovernmentUserDao governmentUserDao = new GovernmentUserDaoImpl();
//getGovernmentUserDetails created by ramya -12-08-18
public GovernmentUserBean getGovernmentUserDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean = governmentUserDao.getGovernmentUserDetails(governmentUserBean);
return governmentUserBean;
}
//getChartDetails
/* public ArrayList<GovernmentUserBean> getChartDetail(GovernmentUserBean governmentUserBean) throws Exception {
ArrayList<GovernmentUserBean> governmentList = new ArrayList<GovernmentUserBean>();
governmentList = governmentUserDao.getChartDetail(governmentUserBean);
return governmentList;
}*/
@Override
public GovernmentUserBean getChartDetails(GovernmentUserBean governmentUserBean,TheaterDetailBean theaterDetailBean) throws Exception {
governmentUserBean=governmentUserDao.getChartDetails(governmentUserBean,theaterDetailBean);
return governmentUserBean;
}
@Override
public ArrayList<GovernmentUserBean> getTheatreListDetails(GovernmentUserBean governmentUserBean) throws Exception {
ArrayList<GovernmentUserBean> districtCityList = new ArrayList<GovernmentUserBean>();
districtCityList =governmentUserDao.getTheatreListDetails(governmentUserBean);
return districtCityList;
}
@Override
public Map<Integer, String> getDistrictMapDetails(GovernmentUserBean governmentUserBean) throws Exception {
Map<Integer,String> districtMap = new HashMap<Integer,String>();
districtMap = governmentUserDao.getDistrictMapDetails(governmentUserBean);
return districtMap;
}
@Override
public GovernmentUserBean getCityMapDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean=governmentUserDao.getCityMapDetails(governmentUserBean);
return governmentUserBean;
}
/*
@Override
public ArrayList<GovernmentUserBean> getGovernmentTheatreWisePieChartDetails(GovernmentUserBean governmentUserBean) throws Exception {
ArrayList<GovernmentUserBean> governmentList = new ArrayList<GovernmentUserBean>();
governmentList = governmentUserDao.getGovernmentTheatreWisePieChartDetails(governmentUserBean);
return governmentList;
}
@Override
public ArrayList<GovernmentUserBean> getTheatreOwnerDetails(GovernmentUserBean governmentUserBean) throws Exception {
ArrayList<GovernmentUserBean> theatreOwnerlist = new ArrayList<GovernmentUserBean>();
theatreOwnerlist = governmentUserDao.getTheatreOwnerDetails(governmentUserBean);
return theatreOwnerlist;
}
*/
@Override
public Map<Integer, byte[]> getTheaterGovtProfileImage(int modelId) throws Exception {
Map<Integer, byte[]> imageMap = new HashMap<Integer,byte[]>();
imageMap = governmentUserDao.getTheaterGovtProfileImage(modelId);
return imageMap;
}
@Override
public GovernmentUserBean getGovernmentTheatreWisePieChartDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean=governmentUserDao.getGovernmentTheatreWisePieChartDetails(governmentUserBean);
return governmentUserBean;
}
//setGovernmentAddUserSubmit created by Nachimuthu
public GovernmentUserBean setGovernmentAddUserSubmit(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean = governmentUserDao.setGovernmentAddUserSubmit(governmentUserBean);
return governmentUserBean;
}
//getGovernmentUserInviteTemplate created by Nachimuthu
public TemplateBean getGovernmentUserInviteTemplate(TemplateBean templateBean) throws Exception {
templateBean = governmentUserDao.getGovernmentUserInviteTemplate(templateBean);
return templateBean;
}
//userRoleMap created by Nachimuthu
public Map<Integer, String> getUserRoleMap() throws Exception {
Map<Integer, String> userRoleMap=new HashMap<Integer,String>();
userRoleMap=governmentUserDao.getUserRoleMap();
return userRoleMap;
}
//getTheaterEmployeeList created by Nachimuthu
public ArrayList<GovernmentUserBean> getGovernmentEmployeeList(GovernmentUserBean governmentUserBean) throws Exception {
ArrayList<GovernmentUserBean> governmentEmployeeList=new ArrayList<GovernmentUserBean>();
governmentEmployeeList=governmentUserDao.getGovernmentEmployeeList(governmentUserBean);
return governmentEmployeeList;
}
//getEmployeeEditDetails created by Nachimuthu
public GovernmentUserBean getEmployeeEditDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean = governmentUserDao.getEmployeeEditDetails(governmentUserBean);
return governmentUserBean;
}
//deleteGovernmentUserEmployeeDetails created by Nachimuthu
public GovernmentUserBean deleteGovernmentUserEmployeeDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean = governmentUserDao.deleteGovernmentUserEmployeeDetails(governmentUserBean);
return governmentUserBean;
}
//setGovernmentUserEmployeeDetails created by Nachimuthu
public GovernmentUserBean setGovernmentUserEmployeeDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean = governmentUserDao.setGovernmentUserEmployeeDetails(governmentUserBean);
return governmentUserBean;
}
//generateGovernmentDashboardExcel created by Nachimuthu
public HSSFWorkbook generateGovernmentDashboardExcel(GovernmentUserBean governmentUserBean) throws Exception {
HSSFWorkbook workbook = governmentUserDao.generateGovernmentDashboardExcel(governmentUserBean);
return workbook;
}
//downloadGovernmentTheatrewiseExcelFile created by Nachimuthu
public HSSFWorkbook downloadGovernmentTheatrewiseExcelFile(GovernmentUserBean governmentUserBean) throws Exception {
HSSFWorkbook workbook = governmentUserDao.downloadGovernmentTheatrewiseExcelFile(governmentUserBean);
return workbook;
}
//getTalukTheatreDetails
public GovernmentUserBean getTalukTheatreDetails(GovernmentUserBean governmentUserBean,
TheaterDetailBean theaterDetailBean) throws Exception {
governmentUserBean=governmentUserDao.getTalukTheatreDetails(governmentUserBean,theaterDetailBean);
return governmentUserBean;
}
//getDistrictTheatreDetailExcelFile
public HSSFWorkbook getDistrictTheatreDetailExcelFile(GovernmentUserBean governmentUserBean) throws Exception {
HSSFWorkbook workbook = governmentUserDao.getDistrictTheatreDetailExcelFile(governmentUserBean);
return workbook;
}
//getTalukwiseTheatreListDetails
public ArrayList<GovernmentUserBean> getTalukwiseTheatreListDetails(GovernmentUserBean governmentUserBean)
throws Exception {
ArrayList<GovernmentUserBean> talukTheatreList = new ArrayList<GovernmentUserBean>();
talukTheatreList = governmentUserDao.getTalukwiseTheatreListDetails(governmentUserBean);
return talukTheatreList;
}
//getTalukTheatreOwnerDetails
public GovernmentUserBean getTalukTheatreOwnerDetails(GovernmentUserBean governmentUserBean) throws Exception {
governmentUserBean=governmentUserDao.getTalukTheatreOwnerDetails(governmentUserBean);
return governmentUserBean;
}
//getTalukTheatreDetailExcelFile
public HSSFWorkbook getTalukTheatreDetailExcelFile(GovernmentUserBean governmentUserBean) throws Exception {
HSSFWorkbook workbook = governmentUserDao.getTalukTheatreDetailExcelFile(governmentUserBean);
return workbook;
}
//setTheatreBookingBlockedDetails
public int setTheatreBookingBlockedDetails(int userId, int roleId, int theatreId,int changeStatusTypeId) throws Exception {
int blocked_satus =governmentUserDao.setTheatreBookingBlockedDetails(userId,roleId,theatreId,changeStatusTypeId);
return blocked_satus;
}
}
|
package com.tencent.mm.plugin.mmsight.model.a;
import android.graphics.Point;
import com.tencent.mm.e.b.c$a;
import com.tencent.mm.plugin.mmsight.model.f;
public interface d {
void E(Runnable runnable);
void Hr(String str);
void Hs(String str);
void O(int i, int i2, int i3);
String Xh();
void a(a aVar);
String aRw();
boolean bdK();
String bej();
float bek();
long bel();
f bem();
c ben();
int beo();
Point bep();
int beq();
boolean ber();
void bes();
c$a bet();
void beu();
void cancel();
void clear();
int d(int i, boolean z, int i2);
String getFileName();
String getFilePath();
void p(int i, int i2, int i3, int i4);
void pause();
void reset();
boolean sQ(int i);
void setFilePath(String str);
}
|
package org.github.chajian.matchgame.runnable;
import org.bukkit.scheduler.BukkitRunnable;
import org.github.chajian.matchgame.bar.NoteBar;
import java.util.ArrayList;
import java.util.List;
/**
* BossBar线程
* @author Chajian
*/
public class BossBarRunnable extends BukkitRunnable {
List<NoteBar> noteBars = new ArrayList<>();
@Override
public void run() {
for(int i = 0 ; i < noteBars.size() ; i++){
NoteBar noteBar = noteBars.get(i);
if (noteBar.decrease()) {
noteBar.destory();
noteBars.remove(i);
}
}
}
public void addNoteBar(NoteBar noteBar){
noteBars.add(noteBar);
}
}
|
package com.moon.moon_proxy.lambda;
import lombok.extern.slf4j.Slf4j;
/**
* @ClassName LambdaExpression
* @Description: TODO
* @Author zyl
* @Date 2020/12/21
* @Version V1.0
**/
@Slf4j
public class LambdaExpression {
/**
* 静态内部类
*
* @param
*/
static class LambdaStatic implements ILamda {
@Override
public void lambda() {
log.info("---------->静态内部类");
}
}
public static void main(String[] args) {
ILamda lambda = new LambdaImpl();
lambda.lambda();
lambda = new LambdaStatic();
lambda.lambda();
lambda = new ILamda() {
@Override
public void lambda() {
log.info("---------->匿名内部类");
}
};
lambda.lambda();
lambda = () -> {
log.info("---------->lambda表达式");
};
lambda.lambda();
IeLamda ieLamda = (String a,String b)->{
log.info("---------->lambda表达式{}",a);
};
ieLamda.lambda("moon","");
ieLamda = (a,b)->{
log.info("---------->lambda表达式{}",a);
};
ieLamda.lambda("moon","");
}
}
interface ILamda {
void lambda();
}
interface IeLamda {
void lambda(String a,String b);
}
@Slf4j
class LambdaImpl implements ILamda {
@Override
public void lambda() {
log.info("---------->实现接口");
}
}
|
package com.rockSolicitors.tests;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openqa.selenium.WebDriver;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import resources.base;
import java.io.IOException;
public class BaseTest extends base {
protected WebDriver driver;
// Initialising log4j object to create logs
private static Logger log = LogManager.getLogger(BaseTest.class.getName());
@BeforeClass
public void startUp() throws IOException {
driver = initialiseDriver();
log.info("Driver is initialised");
driver.get(prop.getProperty("url"));
log.info("Navigating to " + prop.getProperty("url"));
}
@AfterClass
public void tearDown(){
log.info("Closing Browser");
driver.quit();
driver=null;
}
}
|
package Repository;
import Model.Customer;
import java.awt.*;
import java.util.List;
public interface InterfaceCustomer {
Customer save(Customer customer);
List<Customer> findAll();
void delete(Customer customer);
void edit(Customer customer);
}
|
package backtracking;
public class PrintAllPossiblePaths {
private static void printMatrix(int matrix[][], int row, int col, int i, int j, int path[], int index) {
// Add current cell to the path
path[index] = matrix[i][j];
// Reached the bottom of the matrix so we are left with
// only option to move right
if (i == row - 1) {
// Moving to the right direction of the matrix
for (int k = j + 1; k < col; k++) {
path[index + k - j] = matrix[i][k];
}
// Printing the path
for (int l = 0; l < index + col - j; l++) {
System.out.print(path[l] + " ");
}
System.out.println();
return;
}
// Reached the right corner of the matrix we are left with
// only the downward movement.
if (j == col - 1) {
// Downward movement across the matrix
for (int k = i + 1; k < row; k++) {
path[index + k - i] = matrix[k][j];
}
// Printing the path
for (int l = 0; l < index + row - i; l++) {
System.out.print(path[l] + " ");
}
System.out.println();
return;
}
// Print all the paths that are possible after moving down
printMatrix(matrix, row, col, i + 1, j, path, index + 1);
// Print all the paths that are possible after moving right
printMatrix(matrix, row, col, i, j + 1, path, index + 1);
}
public static void main(String[] args) {
int m = 2;
int n = 3;
int mat[][] = { { 1, 2, 3 }, { 4, 5, 6 } };
int maxLengthOfPath = m + n - 1;
printMatrix(mat, m, n, 0, 0, new int[maxLengthOfPath], 0);
}
}
|
package br.com.treinarminas.academicos.operadores;
public class Ativida1 {
public static void main(String[] args) {
int tempo = 1999;
int hora = tempo / 60;
int minuto = tempo % hora;
System.out.println("Tempo: " + hora );
}
}
|
import java.util.*;
public class App {
public static void main(String[] args) {
System.out.println("3 => " + new __Solution().findTheCity(4, new int[][]{{0, 1, 3}, {1, 2, 1}, {1, 3, 4}, {2, 3, 1}}, 4));
}
}
class __Solution {
HashMap<Integer, List<int[]>> map = new HashMap<>();
HashSet[] info;
boolean[] visited;
public int findTheCity(int n, int[][] edges, int trh) {
info = new HashSet[n];
visited = new boolean[n];
for (int i = 0; i < edges.length; i++) {
int from = edges[i][0];
int to = edges[i][1];
int w = edges[i][2];
map.putIfAbsent(from, new ArrayList<>());
map.putIfAbsent(to, new ArrayList<>());
map.get(from).add(new int[]{to, w});
map.get(to).add(new int[]{from, w});
}
for (int i = 0; i < n; i++) {
LinkedList<int[]> q = new LinkedList<>();
int[] start = {i, 0};
q.add(start); // {to , path}
info[start[0]] = new HashSet();
visited[start[0]] = true;
while (!q.isEmpty()) {
int size = q.size();
while (size > 0) {
int[] currInfo = q.poll();
int to = currInfo[0];
int weight = currInfo[1];
for (int[] adjInfo : map.getOrDefault(to, new ArrayList<>())) {
if (weight + adjInfo[1] > trh || adjInfo[0] == i) continue;
q.add(new int[]{adjInfo[0], weight + adjInfo[1]});
info[start[0]].add(adjInfo[0]);
}
size--;
}
}
visited = new boolean[n];
}
System.out.println(Arrays.toString(info));
int min = 1000000;
int ind = 0;
for (int i = 0; i < info.length; i++) {
if (info[i].size() <= min) {
min = info[i].size();
ind = i;
}
}
return ind;
}
}
|
/*
* Copyright 2009 Kjetil Valstadsve
*
* 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 vanadis.extrt;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import vanadis.core.collections.Generic;
import vanadis.core.lang.ToString;
import vanadis.core.lang.UsedByReflection;
import vanadis.common.time.TimeSpan;
import vanadis.ext.Command;
import vanadis.ext.GenericCommand;
import vanadis.osgi.Context;
import vanadis.osgi.Registration;
import java.util.List;
/**
* Starts and stops a {@link FrameworkExtender}. This is the
* chief callback point from the OSGi runtime. When
* {@link #start(org.osgi.framework.BundleContext) the start method}
* returns, vanadis is busy loading and registering bundles.
*/
@UsedByReflection
public final class FrameworkExtenderBundleActivator implements BundleActivator {
private FrameworkExtender frameworkExtender;
private BundleContext bundleContext;
private final List<Registration<Command>> commands = Generic.list();
@UsedByReflection
public FrameworkExtenderBundleActivator() {
log.info(this + " created");
}
@Override
public void start(BundleContext bundleContext) {
this.bundleContext = bundleContext;
start();
}
@Override
public void stop(BundleContext bundleContext) {
unregisterCommands();
stop(true);
}
void restart() {
stop(false);
start();
}
private void start() {
TimeSpan timeout = timeout();
frameworkExtender = new FrameworkExtender(this.bundleContext, timeout);
registerCommands(frameworkExtender.getContext());
log.info(this + " activated");
}
private void stop(boolean finalStop) {
if (frameworkExtender != null) {
frameworkExtender.close(finalStop);
}
frameworkExtender = null;
log.info(this + " deactivated");
}
private void registerCommands(Context context) {
reg(context, new GenericCommand("v-exit-system", "force System.exit()",
context, new SystemExitExecution()));
reg(context, new GenericCommand("v-restart-ext", "restart vanadis extender",
context, new RestartExecution(this)));
}
private void unregisterCommands() {
for (Registration<Command> command : commands) {
command.unregisterSafely();
}
}
private void reg(Context context, Command genericCommand) {
commands.add(context.register(genericCommand, Command.class));
}
private static final Logger log = LoggerFactory.getLogger(FrameworkExtenderBundleActivator.class);
private static final String TIMEOUT_SYSTEM_PROPERTY = "vanadis.timeout";
private static final TimeSpan DEFAULT_TIMEOUT = TimeSpan.HALF_MINUTE;
private static TimeSpan timeout() {
String timeout = System.getProperty(TIMEOUT_SYSTEM_PROPERTY);
if (timeout != null) {
try {
return TimeSpan.parse(timeout);
} catch (Exception e) {
log.warn("Failed to parse timeout in system property " + TIMEOUT_SYSTEM_PROPERTY +
", using default timeout " + DEFAULT_TIMEOUT, e);
}
}
return DEFAULT_TIMEOUT;
}
@Override
public String toString() {
return ToString.of(this, frameworkExtender);
}
}
|
public class Ladder {
public static void main(String[] args) {
int x;
for(x = 0; x < 6; x++) {
if (x==1)
System.out.println("х равно единице");
else if (x==2)
System.out.println("х равно двум");
else if (x==3)
System.out.println("х равно трем");
else if (x==4)
System.out.println("х равно четырем");
else System.out.println("x находиться вне диапазона 1 - 4");
}
}
}
|
package ua.lamp;
import ua.lamp.entity.Lamp;
import ua.lamp.entity.Switcher;
public class Main {
public static void main(String[] args) {
Switcher sw = new Switcher();
Lamp lamp = new Lamp();
//event subscribe
sw.setConsumer(lamp);
sw.switchOn();
sw.switchOff();
}
}
|
package org.holoeverywhere;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
public class HoloEverywhere {
public static enum PreferenceImpl {
JSON, XML
}
/**
* When you call new activity it will be has parent activity theme
*/
public static boolean ALWAYS_USE_PARENT_THEME;
/**
* Print some debug lines in Log
*/
public static boolean DEBUG;
/**
* Disable any overscroll effects for views
*/
public static boolean DISABLE_OVERSCROLL_EFFECT;
/**
* Since 1.5 to preferences can be assigned id instead of key. But for
* saving values in SharedPreferences using key, and it has next format:
*
* <pre>
* preference_0x7fABCDEF
* </pre>
*
* If it options true - key for the preference will be name of id row:
*
* <pre>
* <Preference holo:id="@+id/myCoolPreference" />
* Key for SharedPreferences: myCoolPreference
* </pre>
*/
public static boolean NAMED_PREFERENCES;
/**
* Main package of HoloEverywhere
*/
public static final String PACKAGE;
/**
* Preference implementation using by default
*/
public static PreferenceImpl PREFERENCE_IMPL;
/**
* Wrap any context menu calls by native classes. Like it do ABS on Android
* 4.0+ with options menu
*/
public static boolean WRAP_TO_NATIVE_CONTEXT_MENU;
static {
PACKAGE = HoloEverywhere.class.getPackage().getName();
DEBUG = false;
ALWAYS_USE_PARENT_THEME = false;
NAMED_PREFERENCES = true;
DISABLE_OVERSCROLL_EFFECT = VERSION.SDK_INT < VERSION_CODES.HONEYCOMB;
WRAP_TO_NATIVE_CONTEXT_MENU = VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB;
PREFERENCE_IMPL = PreferenceImpl.XML;
}
private HoloEverywhere() {
}
}
|
package com.ibm.ive.tools.japt.memoryAreaCheck;
import com.ibm.ive.tools.japt.Logger;
import com.ibm.ive.tools.japt.reduction.ita.CreatedObject;
import com.ibm.ive.tools.japt.reduction.ita.DataMember;
import com.ibm.ive.tools.japt.reduction.ita.InstructionLocation;
import com.ibm.ive.tools.japt.reduction.ita.Member;
import com.ibm.ive.tools.japt.reduction.ita.Method;
import com.ibm.ive.tools.japt.reduction.ita.MethodInvocation;
import com.ibm.ive.tools.japt.reduction.ita.ObjectPropagator;
import com.ibm.ive.tools.japt.reduction.ita.PropagatedObject;
import com.ibm.ive.tools.japt.reduction.ita.Repository;
import com.ibm.ive.tools.japt.reduction.ita.ObjectPropagator.PropagationAction;
import com.ibm.jikesbt.BT_CodeAttribute;
import com.ibm.jikesbt.BT_InsVector;
public class ErrorReporter {
com.ibm.ive.tools.japt.ErrorReporter listener;
BT_InsVector invocationInitiators = new BT_InsVector();
BT_InsVector accessInitiators = new BT_InsVector();
boolean checkExternal;
public ErrorReporter(com.ibm.ive.tools.japt.ErrorReporter listener, boolean checkExternal) {
this.listener = listener;
this.checkExternal = checkExternal;
}
CreatedObject findCreator(PropagatedObject object) {
Repository rep = object.getType().repository;
return rep.findCreator(object);
}
public void noteInvocationError(
ErrorWrapper error,
PropagatedObject object,
Member to,
MethodInvocation initiator,
InstructionLocation initiatorLocation) {
//TODO use messages and not the logger directly
if(listener != null && listener.logging() && (checkExternal
|| (initiator != null && initiator.getDefiningClass().isInternal())
|| to.getDeclaringClass().isInternal())
&& !invocationInitiators.contains(initiatorLocation.instruction)) {
invocationInitiators.addElement(initiatorLocation.instruction);
listener.logError(++listener.errorCount + ": potential " + error + Logger.endl);
//TODO provide option -noLoadExternalDebug instead of just -noLoadDebug
listener.logError("\t" + ObjectPropagator.INVOKED.toString(object, to, initiator) + Logger.endl);
Method initiatorMethod = initiator.getMethod();
BT_CodeAttribute code = initiatorMethod.getCode();
int num = code.findLineNumber(initiatorLocation.instruction);
if(num > 0) {
listener.logError("\tinitiated at line number "
+ num + " of " + code.getMethod().getDeclaringClass().getSourceFile()
+ " inside " + initiatorMethod + Logger.endl);
}
CreatedObject origin = findCreator(object);
if(origin != null) {
listener.logError("\t" + origin + Logger.endl);
}
}
}
public void noteReadAccessError(
ErrorWrapper error,
PropagatedObject object,
MethodInvocation to,
InstructionLocation toLocation,
DataMember from,
PropagationAction action) {
String actionString = action.toString(object, to, from);
noteAccessError(error, object, from, to, toLocation, actionString, null);
}
public void noteWriteAccessError(
ErrorWrapper error,
PropagatedObject object,
DataMember to,
MethodInvocation from,
InstructionLocation fromLocation,
PropagationAction action,
PropagatedObject targetObject) {
String actionString = action.toString(object, to, from);
if(noteAccessError(error, object, to, from, fromLocation, actionString, targetObject)) {
CreatedObject targetOrigin = null;
if(targetObject != null) {
targetOrigin = findCreator(targetObject);
if(targetOrigin != null) {
listener.logError("\t" + targetOrigin + Logger.endl);
}
}
}
}
private boolean noteAccessError(
ErrorWrapper error,
PropagatedObject object,
DataMember field,
MethodInvocation initiator,
InstructionLocation initiatorLocation,
String action,
PropagatedObject targetObject) {
if(listener != null && listener.logging() &&
(checkExternal || (initiator != null && initiator.getDefiningClass().isInternal()) || field.getDefiningClass().isInternal())
&& !accessInitiators.contains(initiatorLocation.instruction)) {
accessInitiators.addElement(initiatorLocation.instruction);
listener.logError(++listener.errorCount + ": potential " + error + Logger.endl);
listener.logError("\t" + action + Logger.endl);
Method initiatorMethod = initiator.getMethod();
BT_CodeAttribute code = initiatorMethod.getCode();
int num = code.findLineNumber(initiatorLocation.instruction);
if(num > 0) {
listener.logError("\tinitiated at line number "
+ num + " of " + code.getMethod().getDeclaringClass().getSourceFile()
+ " inside " + initiatorMethod + Logger.endl);
}
CreatedObject origin = findCreator(object);
if(origin != null) {
listener.logError("\t" + origin + Logger.endl);
}
return true;
}
return false;
}
}
|
package py.com.progweb.redsanitaria.model;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
@Entity
@Table(name = "medicos")
public class Medico {
@Id
@Column(name = "codmedico")
@Basic(optional = false )
@GeneratedValue(generator = "codmedico_id_seq",strategy = GenerationType.SEQUENCE)
@SequenceGenerator(name = "codmedico_id_seq", sequenceName = "codmedico_id_seq", allocationSize = 0)
private Integer codmedico;
@Column(name = "dni")
@Basic (optional = false)
private String dni;
@Column(name = "nombre")
@Basic (optional = false)
private String nombre;
@Column(name = "apellido")
@Basic (optional = false)
private String apellido;
@Column(name = "fechanacimiento")
@Basic (optional = false)
@Temporal(TemporalType.DATE)
private Date fechanacimiento;
@Column(name = "esdirector")
@Basic (optional = false)
private String esdirector;
@Column(name = "codhospital")
@Basic (optional = false)
private Integer codhospital;
@OneToOne(mappedBy = "medico")
private Hospital hospital;
@ManyToMany
@JoinTable(
name = "medico_servicio",
joinColumns = @JoinColumn(name = "codmedico", nullable = false),
inverseJoinColumns = @JoinColumn(name="codservicio", nullable = false)
)
Set<Servicio> serviciosList;
public Medico() {
}
public Integer getCodmedico() {
return codmedico;
}
public void setCodmedico(Integer codmedico) {
this.codmedico = codmedico;
}
public String getDni() {
return dni;
}
public void setDni(String dni) {
this.dni = dni;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public Date getFechanacimiento() {
return fechanacimiento;
}
public void setFechanacimiento(Date fechanacimiento) {
this.fechanacimiento = fechanacimiento;
}
public String getEsdirector() {
return esdirector;
}
public void setEsdirector(String esdirector) {
this.esdirector = esdirector;
}
public Integer getCodhospital() {
return codhospital;
}
public void setCodhospital(Integer codhospital) {
this.codhospital = codhospital;
}
public Hospital getHospital() {
return hospital;
}
public void setHospital(Hospital hospital) {
this.hospital = hospital;
}
}
|
package SwordOffer;
/**
* @author renyujie518
* @version 1.0.0
* @ClassName lastNumInQuan_62.java
* @Description
* 0, 1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。
* 求出这个圆圈里剩下的最后一个数字。
*
* 例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。
* “约瑟夫环” 问题，可使用 动态规划 解决
* 数学证明：
* https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/solution/si-bu-he-xin-gong-shi-qing-song-nong-don-3vln/
* 设「i, m问题」的解为 dp[i]；
* dp[i]=(dp[i−1]+m)%i
* dp[1]=0
* @createTime 2021年08月28日 17:45:00
*/
public class lastNumInQuan_62 {
public int lastRemaining(int n, int m) {
int x = 0;
for (int i = 2; i <= n; i++) {
x = (x + m) % i;
}
return x;
}
}
|
package com.tencent.mm.plugin.record.ui;
import android.app.Dialog;
class RecordMsgFileUI$13 implements Runnable {
final /* synthetic */ Dialog iYD;
final /* synthetic */ RecordMsgFileUI mtg;
RecordMsgFileUI$13(RecordMsgFileUI recordMsgFileUI, Dialog dialog) {
this.mtg = recordMsgFileUI;
this.iYD = dialog;
}
public final void run() {
this.iYD.dismiss();
}
}
|
package com.nju.edu.cn.entity;
import javax.persistence.*;
import java.util.List;
/**
* Created by shea on 2018/9/1.
* 用户表
*/
@Entity
@Table(name = "`user`")
public class User {
@Id
@Column(name = "`user_id`")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long userId;
/**
* 账户
*/
@Column(name = "username")
private String username;
/**
* 帐号（邮箱）
*/
@Column(name = "`email`")
private String email;
/**
* 昵称
*/
@Column(name = "`nickname`")
private String nickname;
/**
* 偏好风险等级
*/
@Column(name = "`prefer_risk_level`")
private Integer preferRiskLevel;
/**
* 头像地址
*/
@Column(name = "`avatar`")
private String avatar;
/**
* 登录密码
*/
@Column(name = "`password`")
private String password;
/**
* 用户的交易，进一步应该筛出deleted=false的
*/
// @OneToMany(mappedBy = "user")
// private List<Trade> trades;
/**
* 用户的消息
*/
// @OneToMany(mappedBy = "receiver")
// private List<Message> messages;
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public Integer getPreferRiskLevel() {
return preferRiskLevel;
}
public void setPreferRiskLevel(Integer preferRiskLevel) {
this.preferRiskLevel = preferRiskLevel;
}
public String getAvatar() {
return avatar;
}
public void setAvatar(String avatar) {
this.avatar = avatar;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
// public List<Trade> getTrades() {
// return trades;
// }
//
// public void setTrades(List<Trade> trades) {
// this.trades = trades;
// }
//
// public List<Message> getMessages() {
// return messages;
// }
//
// public void setMessages(List<Message> messages) {
// this.messages = messages;
// }
}
|
package com.qgbase.biz.reportSystem.domain;
import com.qgbase.common.domain.TBaseEntity;
import lombok.Data;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import com.qgbase.excel.annotation.ExcelColumn;
import java.util.Date;
/**
* Created by Mark on 2019-10-11
* 主要用于：代理商用户 实体类定义，此代码为自动生成
*/
@Data
@Entity
@Table(name = "rs_user")
public class RsUser extends TBaseEntity {
@Id
@Column(name = "user_id",unique = true,columnDefinition = "varchar(64) COMMENT '用户id'")
@ExcelColumn(columnName="用户id",order = 1,exportName = "user_id")
@NotNull(message = "用户id不能为空")
private String userId;//create by mark 用户id
@Column(name = "user_name",unique = true,columnDefinition = "varchar(32) COMMENT '用户姓名'")
@ExcelColumn(columnName="用户姓名",order = 2,exportName = "user_name")
private String userName;//create by mark 用户姓名
@Column(name = "user_number",unique = true,columnDefinition = "varchar(32) COMMENT '用户工号'")
@ExcelColumn(columnName="用户工号",order = 3,exportName = "user_number")
private String userNumber;//create by mark 用户工号
@Column(name = "user_phone",unique = true,columnDefinition = "varchar(32) COMMENT '用户手机号'")
@ExcelColumn(columnName="用户手机号",order = 4,exportName = "user_phone")
private String userPhone;//create by mark 用户手机号
@Column(name = "dls_id",unique = true,columnDefinition = "varchar(64) COMMENT '代理商id'")
@ExcelColumn(columnName="代理商id",order = 5,exportName = "dls_id")
private String dlsId;//create by mark 代理商id
@Column(name = "dls_user_type",unique = true,columnDefinition = "varchar(32) COMMENT '用户类型'")
@ExcelColumn(columnName="用户类型",order = 6,exportName = "dls_user_type")
private String dlsUserType;//create by mark 用户类型
@Column(name = "zone_code",unique = true,columnDefinition = "varchar(64) COMMENT '区域编码'")
@ExcelColumn(columnName="区域编码",order = 7,exportName = "zone_code")
private String zoneCode;//create by mark 区域编码
@Column(name = "user_tel",unique = true,columnDefinition = "varchar(32) COMMENT '用户电话'")
@ExcelColumn(columnName="用户电话",order = 8,exportName = "user_tel")
private String userTel;//create by mark 用户电话
@Column(name = "user_qq",unique = true,columnDefinition = "varchar(32) COMMENT '用户QQ号'")
@ExcelColumn(columnName="用户QQ号",order = 9,exportName = "user_qq")
private String userQq;//create by mark 用户QQ号
@Column(name = "is_active",unique = true,columnDefinition = "int(50) COMMENT '是否在职'")
@ExcelColumn(columnName="是否在职",order = 10,exportName = "is_active")
private Integer isActive;//create by mark 是否在职
@Override
public String getPKid()
{
return userId;
}
@Override
public String getObjName(){
return "RsUser";
}
@Override
public String getObjDesc(){
return "代理商用户";
}
}
|
package evm.dmc.api.model;
public enum FrameworkType {
LOCAL, DISTRIBUTED, REMOTE;
}
|
/** ****************************************************************************
* Copyright (c) The Spray Project.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Spray Dev Team - initial API and implementation
**************************************************************************** */
package org.eclipselabs.spray.generator.common;
public class ReservedKeyWords {
public final static String[] RESERVED_KEY_WORDS = {
"AbstractText",
"AlgorithmsFactory",
"AlgorithmsPackage",
"Ellipse",
"GraphicsAlgorithm",
"Image",
"MultiText",
"PlatformGraphicsAlgorithm",
"Polygon",
"Polyline",
"Rectangle",
"RoundedRectangle",
"Text",
"AbstractStyle",
"AdaptedGradientColoredAreas",
"Color",
"Font",
"GradientColoredArea",
"GradientColoreadAreas",
"GradientColoredLocation",
"Point",
"RenderingStyle",
"Style",
"StylesFactory",
"StylesPackage",
"LineStyle",
"LocationType",
"Orientation",
"GraphicsAlgorithmContainer",
"MmFactory",
"MmPackage",
"Property",
"PropertyContainer",
"StyleContainer",
"Literals",
"Anchor",
"AnchorContainer",
"BoxRelativeAnchor",
"ChopboxAnchor",
"Connection",
"ConnectionDecorator",
"ContainerShape",
"Diagram",
"FixPointAnchor",
"FreeFormConnection",
"ManhattenConnection",
"PictogramElement",
"PictogramsFactory",
"PictogramsPackage",
"Shape",
"IGaService",
"AbstractAddConnectionFeature",
"ISprayStyle",
"ISprayConnection",
"Function",
"Activator",
"IFeatureProvider",
"IAddConnectionContext",
"IAddContext",
"EObject",
"IFeatureProvider",
"Graphiti",
"ISprayShape",
"SprayLayoutService",
"GraphitiProperties",
"ConnectionRendering"};
}
|
/**
*
*/
/**
* Copyright 2013 Christian Endres
*
* @author endrescn@fachschaft.informatik.uni-stuttgart.de
*
*/
package org.opentosca.planinvocationengine.service;
|
package br.com.formacao.java.Testes;
import br.com.formacao.java.Modelo.ContaCorrente;
import br.com.formacao.java.Modelo.SaldoInsuficienteException;
import br.com.formacao.java.Modelo.Conta;
/**
* Classe que representa o teste de saque.
*
* @author Guilherme Vilela
* @version 0.1
*/
public class TesteSaca {
/**
*
* @param args
*/
public static void main(String[] args) {
Conta conta = new ContaCorrente(123, 321);
conta.deposita(200.0);
try {
conta.saca(210.0);
}catch (SaldoInsuficienteException ex) {
System.out.println("EX: " + ex.getMessage());
}
System.out.println(conta.getSaldo());
}
}
|
package com.smxknife.mapstruct.demo01;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @author smxknife
* 2021/1/19
*/
@Mapper
public interface PersonConverter {
PersonConverter INSTANCE = Mappers.getMapper(PersonConverter.class);
/**
* auto converter
* @param person
* @return
*/
@Mappings({
@Mapping(source = "dateTime", target = "time"),
@Mapping(source = "dateTime", target = "timeFormat", dateFormat = "yyyy-MM-dd HH:mm:ss"),
@Mapping(target = "timeExpression", expression = "java(java.time.format.DateTimeFormatter.ofPattern(\"yyyy-MM-dd HH:00:00\").format(person.getDateTime()))"),
@Mapping(source = "user.age", target = "age"),
@Mapping(target = "email", ignore = true)
})
PersonDTO domain2dto(Person person);
}
|
2016.11.09.
8. Java EA
strukturált programozás:
- nincsenek ugró utasítások
- szekvencia, elágazás, ciklus
- nincs szükség goto, break, continue utasításokra
- goto nincs is Javában, break és continue van
1. ökölszabály: programozzunk strukturáltan
2. ökölszabály: nincsenek korlátlan hatalmú szabályok, időnként az ökölszabályt is meg lehet szegni (időnként és jó okkal)
ciklus esetén:
- break: kiugrik a ciklusból
- continue: ciklusmag végére ugrik
switch:
- break-et használunk a strukturált stílus követéséhez mind ág végén
- break nélkül nem is igen nevezhető strukturáltnak
kivételek kiváltása/kezelése:
- vmilyen értelemben kilép a strukturált programozás kereteiből (lexikálisan)
(de azért vmi struktúrát megőriz, dinamikus struktúra azaz metódushívások)
- modern nyelvekben gyakran használt lehetőség
Java programozók: intenzíven
OOP
interfész interface
--------- ---------
osztály tartalmának leszűktése nyelvi konstrukció
kívülről megfigyelhető nézetre típusdefiníciós eszköz
absztrakció: private részletektpl való elvonatkozás kifejezése referenciatípusok
Java nyelv: class != interface
JVM: class és interface hasonló
fordítás után: .class bájtkód
interface segítségével jól megadhatók az osztályok interfésze explicitté tehetők
public interface Runnable {
public void run();
}
nyilvános run metódussal rendelkezzen egy osztály
class Lion implements Runnable {
private float weight;
public void feed() { ... } // definiáljuk a műveleteket
public void run() { ... } //megadjuk az implementációt is
}
deklaráció: bejelentem h van, és magadom azokat a tulajdonságait amik alapján használni lehet
definíció: meghatározom, azaz megmondom hogyan működik
Lion deklarálja és definiálja a feed metódust
interface: típusként használható, nem példányosítható
class: típuskénti s használható, példáonysítható is
típus:
- változó
- formális paraméter
- metódus visszatérési érték
típusa megmondja hogyan használható (típushelyes használat)
a nyelv statikus szemantikai szabályait tartatom bejelentem
Runnable valtozo;
...
valtozo.run(); // típushelyes
valtozo = new Lion()
public interface Closeable {
void close(); // pongyolaság
}
interface-ben automatikusan minden metódusdeklaráció public
a megvalósító class-ban szintén public kell legyen (itt viszont ki is kell írni)
class Lion implements Runnable, Closeable {
private float weight;
public void feed() { ... } // definiáljuk a múveleteket
public void run() { ... } // megadjuk az implementációt is
public void close() { ... } // kell a public
}
osztály: esetleg bonyolult, összetett viselkedés amely több kontextusban is használható lehet (több interface-t is megvalósít)
interfész: az implementált interface-ek közössége, valamindm inden egyéb public dolog amit nem nevesítettem interface formájában
ugyaanazt az interface-t több osztályi is megvalósíthatja
különböző megvalósításoktól való elvonatkoztatás lehetősége
Lion leo; // nem érdekel mi van a Lion-on belől, elvoatkoztatunk a belső működéstől
Closeable leo; // attól is elvoatkoztatunk h többféle impelementáció is léthethet, leo lehet akár FileInputStrem
absztraktabb programozást tesz lehetővé az interfacejó OOP programozó törekszik az interface-ek használatára típusként
classt akkor használ ha példáonysít, vagy olyan helyzetben kell típust használnia amelyben nem létezik a használatot kifejező interface
package java.util;
public interface List<T> {
void add(T item) { ... }
boolean contains(T item) { ... } // pongyola
T get(int index) { ... }
}
hasonlóan a LinkedList is
extrém eset: 0 db metódus
package java.io;
public interface Serializable {}
class Lion implements java.io.Serializable {}
java.lang.Cloneable;
|
package com.yedam;
class CellPhone {
String model;
String color;
CellPhone() {
}
CellPhone(String model, String color) {
this.model = model;
this.color = color;
}
void powerOn() {
System.out.println("전원을 켭니다.");
}
void powerOff() {
System.out.println("전원을 끕니다.");
}
void bell() {
System.out.println("벨이 울립니다.");
}
void sendVoice(String message) {
System.out.println("자신" + message);
}
void receiveVoic(String message) {
System.out.println("상대방:" + message);
}
void handUp() {
System.out.println("전하ㅗ를 끊습니다.");
}
}
class DmbCellPhone extends CellPhone {
int channel;
DmbCellPhone() {
}
DmbCellPhone(String model, String color, int channel) {
super(model, color);
this.channel = channel;
}
void turnOnDmb() {
System.out.println("채널: " + channel);
}
void changeChannelDmb(int Channel) {
this.channel = channel;
System.out.println("채널을" + channel + "번으로 바꿉니다.");
}
void turnOffdmb() {
System.out.println("끔");
}
@Override
void handUp() {
System.out.println("끊스니다.");
}
}
public class DmbCellPhoneExample {
public static void main(String[] args) {
DmbCellPhone dcp = new DmbCellPhone("SMT-300","RED",10);
dcp.bell();
System.out.println(dcp.channel);
dcp.changeChannelDmb(20);
System.out.println(dcp.channel);
dcp.turnOnDmb();
dcp.bell();
dcp.turnOffdmb();
}
}
|
package com.steatoda.commons.fields.model.carrier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.steatoda.commons.fields.FieldGraph;
import com.steatoda.commons.fields.demo.model.person.Person;
import com.steatoda.commons.fields.demo.model.person.PersonDemoData;
import com.steatoda.commons.fields.demo.model.person.PersonDemoService;
import com.steatoda.commons.fields.demo.model.person.PersonService;
public class CarrierDemoService implements CarrierService {
@Override
public Carrier get(String id, FieldGraph<Carrier.Field> graph) {
if (!"enterprise".equals(id))
return null;
if (graph.isEmpty())
return Carrier.ref(id);
Carrier carrier = new Carrier();
carrier.setId(id);
for (Carrier.Field field : graph) {
FieldGraph<Person.Field> personGraph = graph.getGraph(field, Person.Field.class);
switch (field) {
case name:
carrier.setName("Enterprise");
break;
case entity:
carrier.setEntity(personService.get(PersonDemoData.RonId, personGraph));
break;
case list:
carrier.setList(buildList(personGraph));
break;
case set:
carrier.setSet(buildSet(personGraph));
break;
case map:
carrier.setMap(buildMap(personGraph));
break;
case listlist:
List<List<Person>> listlist = new ArrayList<>();
listlist.add(buildList(personGraph));
listlist.add(buildList(personGraph));
listlist.add(buildList(personGraph));
carrier.setListList(listlist);
break;
case setset:
Set<Set<Person>> setset = new HashSet<>();
setset.add(buildSet(personGraph));
setset.add(buildSet(personGraph));
setset.add(buildSet(personGraph));
carrier.setSetSet(setset);
break;
case maplist:
Map<String, List<Person>> maplist = new HashMap<>();
maplist.put("first", buildList(personGraph));
maplist.put("second", buildList(personGraph));
maplist.put("third", buildList(personGraph));
carrier.setMapList(maplist);
break;
case mapset:
Map<String, Set<Person>> mapset = new HashMap<>();
mapset.put("first", buildSet(personGraph));
mapset.put("second", buildSet(personGraph));
mapset.put("third", buildSet(personGraph));
carrier.setMapSet(mapset);
break;
case mapmap:
Map<String, Map<String, Person>> mapmap = new HashMap<>();
mapmap.put("first", buildMap(personGraph));
mapmap.put("second", buildMap(personGraph));
mapmap.put("third", buildMap(personGraph));
carrier.setMapMap(mapmap);
break;
case mapentitylist:
Map<Person, List<Person>> mapentitylist = new HashMap<>();
mapentitylist.put(personService.get(PersonDemoData.RonId, personGraph), buildList(personGraph));
mapentitylist.put(personService.get(PersonDemoData.PirateId, personGraph), buildList(personGraph));
mapentitylist.put(personService.get(PersonDemoData.JohnId, personGraph), buildList(personGraph));
carrier.setMapEntityList(mapentitylist);
break;
}
}
return carrier;
}
private List<Person> buildList(FieldGraph<Person.Field> fields) {
List<Person> persons = new ArrayList<>();
persons.add(personService.get(PersonDemoData.RonId, fields));
persons.add(personService.get(PersonDemoData.PirateId, fields));
persons.add(personService.get(PersonDemoData.JohnId, fields));
return persons;
}
private Set<Person> buildSet(FieldGraph<Person.Field> fields) {
Set<Person> persons = new HashSet<>();
persons.add(personService.get(PersonDemoData.RonId, fields));
persons.add(personService.get(PersonDemoData.PirateId, fields));
persons.add(personService.get(PersonDemoData.JohnId, fields));
return persons;
}
private Map<String, Person> buildMap(FieldGraph<Person.Field> fields) {
Map<String, Person> persons = new HashMap<>();
persons.put("ron", personService.get(PersonDemoData.RonId, fields));
persons.put("pirate", personService.get(PersonDemoData.PirateId, fields));
persons.put("john", personService.get(PersonDemoData.JohnId, fields));
return persons;
}
@SuppressWarnings("unused")
private static final Logger Log = LoggerFactory.getLogger(CarrierDemoService.class);
private final PersonService personService = new PersonDemoService();
}
|
package com.tencent.mm.plugin.appbrand.jsapi.f;
import com.tencent.mm.plugin.appbrand.jsapi.h;
public class i$d extends h {
private static final int CTRL_INDEX = 151;
private static final String NAME = "onMapClick";
}
|
package com.study.rxjava;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import java.util.concurrent.TimeUnit;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
//入门
public void studySimple(View view) {
RxJavaHelper.getHelper().studySimple();
}
//体验链式编程 chain 锁链
public void studyChain(View view) {
RxJavaHelper.getHelper().studyChain();
}
//线程切换
public void threadChange(View view) {
RxJavaHelper.getHelper().studyThread();
}
//map操作符
public void mapStudy(View view) {
RxJavaHelper.getHelper().studyMap();
}
public void flatmapStudy(View view) {
RxJavaHelper.getHelper().studyFlatMap();
}
}
|
package com.kangYh.fangdou2.di;
/**
* Created by solo on 2018/1/10.
* 依赖注入帮助类
*/
public class DIHelper {
// public static ActivityComponent getActivityComponent() {
// return DaggerActivityComponent.builder()
// .applicationComponent(MyApplication.getApplicationComponent())
// .build();
// }
}
|
package com.isystk.sample.web.base.security;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
/**
* 基底セキュリティコンフィグ
*/
public abstract class BaseSecurityConfig extends WebSecurityConfigurerAdapter {
}
|
package com.qf.controller;
import com.qf.entity.FriendRequest;
import com.qf.entity.Friends;
import com.qf.entity.ResultData;
import com.qf.service.IFriendRequestService;
import com.qf.util.Constant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
@RequestMapping("/friend")
public class FriendsController {
@Autowired
private IFriendRequestService friendRequestService;
@RequestMapping("/insertFriendRequest")
public ResultData<Boolean> insertFriendRequest(FriendRequest friendRequest){
int result = friendRequestService.insertFriendRequest(friendRequest);
if (result>0){
//添加好友申请成功
return ResultData.createSuccResultData(true);
}else if (result == -1){
return ResultData.createErrorResultData(Constant.ERROR_CODE,"请不要重复添加");
}else if (result == -2){
return ResultData.createErrorResultData(Constant.ERROR_CODE,"你们已经是好友了!");
}
return ResultData.createErrorResultData(Constant.ERROR_CODE,"服务器异常");
}
@RequestMapping("/queryFriendRequest")
public ResultData<List<FriendRequest>> queryFriendRequest(int fromid){
List<FriendRequest> requestList = friendRequestService.queryFriendRequest(fromid);
if (requestList.size()>0 && requestList !=null){
return ResultData.createSuccResultData(requestList);
}
return ResultData.createErrorResultData(Constant.ERROR_CODE,"没有任何申请");
}
@RequestMapping("/friendRequestHandler")
public ResultData<Boolean> friendRequestHandler(int rid,int status){
System.out.println("status---->"+status);
int result = friendRequestService.friendRequestHandler(rid, status);
return ResultData.createSuccResultData(true);
}
@RequestMapping("/listByUid")
public ResultData<List<Friends>> listByUserId(int uid){
List<Friends> friends = friendRequestService.listByUid(uid);
System.out.println("好友列表---->"+friends);
return ResultData.createSuccResultData(friends);
}
}
|
package com.concurrent.synchronize;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
/**
*
* synchronized练习 (面试题：保证线程的顺序)
*
* 三个线程并发顺序打印 a b c (打印四次)
* ReentrantLock版
*
*/
@Slf4j(topic = "learn")
public class SynchronizedInterview05 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock mReentrantLock = new ReentrantLock();
Condition mCondition = mReentrantLock.newCondition();
Sync sync = new Sync();
Thread wThread01 = new Thread(() -> {
sync.print("a", 1, 2, mReentrantLock, mCondition);
}, "Thread01");
Thread wThread02 = new Thread(() -> {
sync.print("b", 2, 3, mReentrantLock, mCondition);
}, "Thread02");
Thread wThread03 = new Thread(() -> {
sync.print("c", 3, 1, mReentrantLock, mCondition);
}, "Thread03");
wThread03.start();
TimeUnit.SECONDS.sleep(1);
wThread01.start();
TimeUnit.SECONDS.sleep(1);
wThread02.start();
}
static class Sync {
private AtomicInteger fag = new AtomicInteger(1);
private AtomicInteger count = new AtomicInteger(0);
@SneakyThrows
public void print(String str, int waitTag, int nextTag, ReentrantLock reentrantLock, Condition condition) {
while (true){
try {
reentrantLock.lock();
while (fag.get() != waitTag) {
condition.await();
}
log.debug(Thread.currentThread().getName() + "打印:" + str);
fag.getAndSet(nextTag);
if (waitTag == 1) {
count.getAndAdd(1);
if (count.get() == 4) {
break;
}
}
condition.signalAll();
} finally {
reentrantLock.unlock();
}
}
}
}
}
|
package com.nv95.ficbook;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.res.Resources;
import android.text.Html;
import android.view.Gravity;
import android.widget.Toast;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class FbHelper {
Activity parent_activity;
public FbHelper(Activity parent_activity) {
this.parent_activity = parent_activity;
}
private String getStringFromRawFile(Activity activity) {
try {
Resources r = activity.getResources();
InputStream is = r.openRawResource(R.raw.changelog);
String myText = null;
myText = convertStreamToString(is);
is.close();
return myText;
} catch (IOException e) {
return e.getMessage();
}
}
String getStringFromRawFile(int res) {
try {
Resources r = parent_activity.getResources();
InputStream is = r.openRawResource(res);
String myText;
myText = convertStreamToString(is);
is.close();
return myText;
} catch (IOException e) {
return e.getMessage();
}
}
private String convertStreamToString(InputStream is) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int i = is.read();
while( i != -1)
{
baos.write(i);
i = is.read();
}
return baos.toString();
}
public void showChangelog(){
AlertDialog.Builder builder = new AlertDialog.Builder(parent_activity);
builder.setTitle(R.string.changelog)
.setMessage(getStringFromRawFile(parent_activity))
.setCancelable(true)
.setNegativeButton("Закрыть",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
}
);
builder.create().show();
}
public void showContextHelp(int flag){
Intent intent = new Intent(parent_activity,HelpActivity.class);
if (parent_activity.getClass().equals(MainActivity.class))
intent.putExtra("key",1);
else if (parent_activity.getClass().equals(FindActivity.class))
intent.putExtra("key",2);
else if (parent_activity.getClass().equals(FicManager.class))
intent.putExtra("key",3);
parent_activity.startActivity(intent.putExtra("flag",flag));
parent_activity.overridePendingTransition(R.anim.helper_enter,R.anim.helper_exit);
parent_activity.getSharedPreferences("helper", Context.MODE_PRIVATE).edit().putBoolean(parent_activity.getClass().getName(),false).commit();
}
public void showGenreDescription(int index){
try {
Toast toast = Toast.makeText(parent_activity, Html.fromHtml(parent_activity.getResources().getStringArray(R.array.genred)[index]), Toast.LENGTH_LONG);
toast.setGravity(Gravity.CENTER,0,0);
toast.show();
}catch (Exception ignored){
}
}
public String getGenreDescription(String genre){
String[] a = parent_activity.getResources().getStringArray(R.array.genres_url);
String s;
for (int i=1;i<a.length;i++){
s = a[i];
s=s.substring(s.lastIndexOf("/")+1);
if (genre.equalsIgnoreCase(s)) {
return parent_activity.getResources().getStringArray(R.array.genred)[i-1];
}
}
return "";
}
public void requestDonate(){
AlertDialog.Builder builder = new AlertDialog.Builder(parent_activity);
builder
.setMessage(Html.fromHtml(getStringFromRawFile(R.raw.donate)))
.setCancelable(true)
.setTitle(R.string.donate)
.setNegativeButton("Закрыть",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
}
);
builder.create().show();
}
}
|
package com.Bank;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;
import java.util.regex.Pattern;
public class Bank {
private final String name;
private int Pin;
private double USD;
private boolean Unlocked = false;
private File file = new File("test.txt");
private Deposit deposit;
public Bank(String name) {
this.name = name;
if(hasPin()) {
System.out.println(name+" has a pin already");
setPin(getPin());}
else{
System.out.println("No pin found... Creating one for you.");
setPin(getRandomNumberInRange(1000, 9999));
writePin();
}
}
private boolean hasPin() {
String line;
if (!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
try {
BufferedReader reader = new BufferedReader(new FileReader(file));
line = reader.readLine();
System.out.println(line);
reader.close();
if(line == null){return false;}
if(line.length() < 4){return false;}
if(Pattern.matches("[a-zA-Z.?]+", line) == true){return false;}
} catch (Exception e) {
e.printStackTrace();
}
return true;
}
public String getName() {
return name;
}
private int getPin() {
String line = null;
try {
BufferedReader reader = new BufferedReader(new FileReader(file));
line = reader.readLine();
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
return Integer.parseInt(line);
}
private void writePin() {
String line = Integer.toString(Pin);
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(file));
writer.write(line);
writer.close();
System.err.println("Written Pin down for you in: "+file.getAbsolutePath());
} catch (IOException e) {
e.printStackTrace();
}
}
private void setPin(int pin) {
Pin = pin;
}
public boolean isUnlocked() {
if(Unlocked)
return true;
return false;
}
public void gainAccess(int PinNum) {
if (PinNum == Pin)
Unlocked = true;
else
System.out.println("Access Denied.");
}
private int getRandomNumberInRange(int min, int max) {
Random r = new Random();
return r.nextInt((max - min) + 1) + min;
}
public String toString() {
if(Unlocked){return name + " | Money: "+USD;}
else {return name + " #LOCKED#";}
}
}
|
package com.lzw;
public class Person2 {
protected String name = "person";
protected int age = 90;
public String getInfo() {
return "Name£º" + name + "\tage£º" + age;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
|
package com.malf;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author malf
* @description TODO
* @project how2jStudy
* @since 2020/10/28
*/
public class TmallTest {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try (Connection coon = DriverManager.getConnection("jdbc:mysql://localhost:3306/how2java?useUnicode=true&characterEncoding=utf8",
"root", "password");
Statement stat = coon.createStatement();
) {
for (int i = 0; i < 10; i++) {
String sqlFormat = "insert into category values (null, '测试分类%d')";
String sql = String.format(sqlFormat, i);
stat.execute(sql);
}
System.out.println("创建了10条分类数据");
} catch (SQLException e) {
e.printStackTrace();
}
}
}
|
package other;
public class TrieNode {
private TrieNode[] children;
public boolean isLeaf;
private int childCount;
public TrieNode() {
children = new TrieNode[26];
isLeaf = false;
childCount = 0;
}
public boolean containsKey(Character c) {
return children[c - 'a'] != null;
}
public void put(Character c, TrieNode node) {
children[c - 'a'] = node;
childCount++;
}
public TrieNode get(Character c) {
return children[c - 'a'];
}
public Character getCharacter(int i) {
return (char) (i + 'a');
}
public TrieNode[] getChildren() {
return this.children;
}
public int getChildCount() {
return childCount;
}
}
|
package servlets;
import java.util.HashMap;
import java.util.Map;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.google.gson.Gson;
import beans.Transistor;
import beans.User;
/**
* Servlet implementation class Login
*/
@WebServlet("/Login")
public class Login extends HttpServlet {
private boolean connected;
// Get status
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
HttpSession session = request.getSession();
User user = (User) session.getAttribute("user");
if(user != null) {
System.out.println(user.toString());
}
String json = new Gson().toJson(user.connected());
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
PrintWriter out = response.getWriter();
out.print(json);
}
// Log in
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
User user = getUserFromRequest(request);
HttpSession session = request.getSession();
session.setAttribute("user", user);
doGet(request, response);
}
private static User getUserFromRequest(HttpServletRequest request) throws IOException {
StringBuilder buffer = new StringBuilder();
BufferedReader reader = request.getReader();
String line;
while ((line = reader.readLine()) != null) {
buffer.append(line);
}
String data = buffer.toString();
System.out.println(data);
// Json treatment
Gson gson = new Gson();
User user = gson.fromJson(data, User.class);
return user;
}
}
|
package com.bitbus.fantasyprep.auction;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
public interface PlayerAuctionRepository extends JpaRepository<PlayerAuction, Integer> {
List<PlayerAuction> findByAuction(Auction auction);
}
|
package com.amoraesdev.mobify.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import com.amoraesdev.mobify.web.WebsocketHandler;
/**
* Websocket configuration class
* @author Alessandro Moraes (alessandro at amoraesdev.com)
*/
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Autowired
private WebsocketHandler handler;
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(handler, "/ws/notifications").setAllowedOrigins("*");
registry.addHandler(handler, "/sockjs/notifications").setAllowedOrigins("*").withSockJS();
}
}
|
/**
*
*/
package ru.biv.msgSystem;
import ru.biv.base.Abonent;
import ru.biv.base.Address;
import ru.biv.base.Frontend;
import ru.biv.base.Msg;
/**
* @author Banshikov Igor (BIV)
*
*/
public abstract class MsgToFrontend extends Msg {
public MsgToFrontend(Address from, Address to){
super(from,to);
}
/* (non-Javadoc)
* @see ru.biv.msgSystem.Msg#exec(ru.biv.msgSystem.Abonent)
*/
@Override
public void exec(Abonent abonent) {
if(abonent instanceof Frontend) {
exec((Frontend)abonent);
}
}
public abstract void exec(Frontend frontend);
}
|
package org.apache.hadoop.examples;
import java.io.*;
import java.util.*;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
/**
* This is an example Hadoop Map/Reduce application.
* It reads the text input files each line of the format <A1;A2;.....;A12>, and produces <<A1;A2;..;A11>,A12>
* as Map output.
* The Reduce output is a list of all candidates for the self join common items
*
*
* To run: bin/hadoop jar build/hadoop-examples.jar selfjoin
* [-m <i>maps</i>] [-r <i>reduces</i>] <i>in-dir</i> <i>out-dir</i>
*
* @author Faraz Ahmad
*/
@SuppressWarnings("deprecation")
public class SelfJoin extends Configured implements Tool{
private enum Counter { WORDS, VALUES }
public static final Log LOG = LogFactory.getLog("org.apache.hadoop.examples.SelfJoin");
public static class MapClass extends Mapper<LongWritable, Text, Text, Text> {
public void map(LongWritable key, Text value,
Context context) throws IOException,InterruptedException {
String line = new String();
String kMinusOne = new String();
String kthItem = new String();
int index;
line = ((Text)value).toString();
index = line.lastIndexOf(",");
if(index == -1) {
LOG.info("Map: Input File in wrong format");
return;
}
kMinusOne = line.substring(0,index);
kthItem = line.substring(index+1);
context.write(new Text(kMinusOne), new Text(kthItem));
context.getCounter(Counter.WORDS).increment(1);
}
}
/**
* A reducer class that makes combinations for candidates.
*/
public static class Reduce extends Reducer<Text, Text, Text, Text> {
public void reduce(Text key, Iterator<Text> values,
Context context) throws IOException,InterruptedException {
String value = new String("");
String outVal = new String ("");
List<String> kthItemList = new ArrayList<String>();
while (values.hasNext()){
value = ((Text) values.next()).toString();
kthItemList.add(value);
}
Collections.sort(kthItemList);
for (int i = 0; i < kthItemList.size() - 1; i++){
for (int j = i+1; j < kthItemList.size(); j++) {
outVal = kthItemList.get(i) + "," + kthItemList.get(j);
context.write(key,new Text(outVal));
}
}
}
}
/**
* A combiner class that removes the duplicates in the map output.
*/
public static class Combine extends Reducer<Text, Text, Text, Text> {
public void reduce(Text key, Iterator<Text> values,
Context context) throws IOException,InterruptedException {
String value = new String("");
List<String> kthItemList = new ArrayList<String>();
while (values.hasNext()){
value = ((Text) values.next()).toString();
kthItemList.add(value);
}
for (int i = 0; i < kthItemList.size(); i++){
context.write(key,new Text(kthItemList.get(i)));
}
}
}
static void printUsage() {
System.out.println("selfjoin [-m <maps>] [-r <reduces>] <input> <output>");
System.exit(1);
}
/**
* The main driver for map/reduce program.
* Invoke this method to submit the map/reduce job.
* @throws IOException When there is communication problems with the
* job tracker.
*/
public int run(String[] args) throws Exception {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "SelfJoin");
job.setJobName("selfjoin");
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setMapperClass(MapClass.class);
job.setCombinerClass(Combine.class);
job.setReducerClass(Reduce.class);
List<String> other_args = new ArrayList<String>();
for(int i=0; i < args.length; ++i) {
try {
if ("-m".equals(args[i])) {
} else if ("-r".equals(args[i])) {
job.setNumReduceTasks(Integer.parseInt(args[++i]));
} else {
other_args.add(args[i]);
}
} catch (NumberFormatException except) {
System.out.println("ERROR: Integer expected instead of " + args[i]);
printUsage();
} catch (ArrayIndexOutOfBoundsException except) {
System.out.println("ERROR: Required parameter missing from " +
args[i-1]);
printUsage(); // exits
}
}
// Make sure there are exactly 2 parameters left.
if (other_args.size() != 2) {
System.out.println("ERROR: Wrong number of parameters: " +
other_args.size() + " instead of 2.");
printUsage();
}
FileInputFormat.addInputPath(job, new Path(other_args.get(0)));
String outPath = new String(other_args.get(1));
FileOutputFormat.setOutputPath(job, new Path(outPath));
Date startTime = new Date();
System.out.println("Job started: " + startTime);
Boolean waitforCompletion = job.waitForCompletion(true) ;
Date end_time = new Date();
System.out.println("Job ended: " + end_time);
System.out.println("The job took " +
(end_time.getTime() - startTime.getTime()) /1000 + " seconds.");
return 0;
}
public static void main(String[] args) throws Exception {
int ret = ToolRunner.run(new SelfJoin(), args);
System.exit(ret);
}
}
|
package org.usfirst.frc.team1165.robot.commands.rotary_lift;
import org.usfirst.frc.team1165.robot.Robot;
import org.usfirst.frc.team1165.robot.util.drivers.OperatorInterface;
import edu.wpi.first.wpilibj.command.Command;
/**
*
*/
public class RotaryLiftDown extends Command
{
public RotaryLiftDown()
{
requires(Robot.mRotaryLift);
}
@Override
protected void execute()
{
Robot.mRotaryLift.down();
}
@Override
protected boolean isFinished()
{
return !OperatorInterface.getRotaryLiftDown();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.