java,Code片段,代码实例,代码示例,代码片段库

java 数学题

pow

//pow(x,k)
//二分搜索
public double mypow(int x,int n){
  if(n==0) return 1;
  if(n==1) return x;
  double half = mypow(x,n/2);
  if(n%2==0) return half*half;
  if(n>0) return half*half*x;
  return half*half/x;
}

sqrt1-1

//求一个数的平方根，输入数字x是一个Integer,输出结果是一个Integer
//二分查找法
public int mine_sqrt(int x){
  int left = 1,right=x-1;
  if(x==1) return 1;
  while(left < right){
    int mid = left+(right-left)/2;
    if(x/mid==mid) return mid;
    else if(x/mid > mid) left = mid+1;
    else right=mid;//这里right不等于mid+1,而left等于mid+1
  }
  return right-1;
}

sqrt1-2

//给定一个正数求其平方根
//另一种二分查找法
public int my_sqrt(int x){
  int left=  1;
  int right = x/2+1;
  while(left <= right){
    int mid = left+(right-left)/2;
    if(mid*mid==x) return mid;
    else if(x/mid>mid) left = mid+1;
    else right=mid-1;
  }
  return right;
}

sqrt2

//求解一个正整数的平方根，返回正整数
//牛顿迭代法：https://www.cnblogs.com/AnnieKim/archive/2013/04/18/3028607.html
public int newtun_sqrt(int x){
  double res = x-1;
  while(res*res-x>0.0001){
    res = (res+x/res)/2;
  }
  return int(res);
}

java 统一参数解析类

CurrentUserMethodArgumentResolver.java

package com.markor.common.mvc.token;

import com.alibaba.fastjson.JSON;
import com.markor.common.mvc.sKey.CurrentSKey;
import com.markor.common.mvc.sKey.SKeyManager;
import com.markor.common.mvc.sKey.bo.SkeyInfo;
import com.markor.common.mvc.token.bo.TokenUserInfo;
import com.markor.common.mvc.token.jwt.JWTConstance;
import com.markor.common.mvc.token.jwt.JWTUtil;
import mk.marketing.wechat.program.WechatProgramUser;
import mk.marketing.wechat.program.corp.CorpAppToken;
import mk.marketing.wechat.program.corp.TokenManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

/**
 * @author sunnannan
 * @Title: CurrentUserMethodArgumentResolver
 * @ProjectName mk-marketing-service
 * @Description: 自定义controller 参数解析器 配合注解使用 当controller中存在这个类型的参数和注解，会将request中保存的token'信息写入
 * @date 2018/10/1815:29
 */
@Service
public class CurrentUserMethodArgumentResolver implements HandlerMethodArgumentResolver {

    private static final String HEADER_SOURCE_GATEWAY = "zuul-source-gateway";

    private static final String HEADER_APP_CODE = "zuul-wechat-corp-app-code";

    private static final String HEADER_ACCOUNT_NAME = "zuul-wechat-corp-account-name";

    private static final String HEADER_WX_USER_ID = "zuul-wechat-wx-user-id";

    @Autowired
    private SKeyManager sKeyManager;

    @Autowired
    private TokenManager tokenManager;

    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
        if (methodParameter.hasParameterAnnotation(CurrentUser.class) &&
                (methodParameter.getParameterType().isAssignableFrom(TokenUserInfo.class)
                        || methodParameter.getParameterType().isAssignableFrom(WechatProgramUser.class)
                        || methodParameter.getParameterType().isAssignableFrom(CorpAppToken.class))) {
            return true;
        }
        if (methodParameter.getParameterType().isAssignableFrom(SkeyInfo.class) && methodParameter.hasParameterAnnotation(CurrentSKey.class)) {
            return true;
        }
        return false;
    }

    @Override
    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {

        if (methodParameter.hasParameterAnnotation(CurrentUser.class)) {
            // 获取头信息"zuul-source-gateway"，得到该请求时从哪个代理转发过来的（企业应用Gateway/C端用户Gateway/后台管理Gateway）
            String sourceGateway = nativeWebRequest.getHeader(HEADER_SOURCE_GATEWAY);
            if ("wechat-corp-gateway".equals(sourceGateway)) { // -------------------------------- wechat-corp-gateway 企业应用
                /*
                  因为wechat-corp-gateway要对访问的接口做业务登录校验过滤，因此解析Token的动作在gateway中已完成，解析后的appCode和
                  accountName直接通过header传递进来
                 */
                String appCode = nativeWebRequest.getHeader(HEADER_APP_CODE);
                String accountName = nativeWebRequest.getHeader(HEADER_ACCOUNT_NAME);
                if (methodParameter.getParameterType().isAssignableFrom(TokenUserInfo.class)) { // 返回系统用户会话信息
                    String userInfoJson = tokenManager.getCurrentUserInfo(appCode, accountName);
                    if (userInfoJson != null) {
                        return JSON.parseObject(userInfoJson, TokenUserInfo.class);
                    }
                } else if (methodParameter.getParameterType().isAssignableFrom(WechatProgramUser.class)) { // 返回微信用户信息
                    return tokenManager.getWechatProgramUserInfo(appCode, nativeWebRequest.getHeader(HEADER_WX_USER_ID));
                } else if (methodParameter.getParameterType().isAssignableFrom(CorpAppToken.class)) { // 返回微信登录Token
                    return tokenManager.parseToken(nativeWebRequest.getHeader(JWTConstance.TOKEN_INFO));
                }
            } else if ("admin-gateway".equals(sourceGateway)) { // -------------------------------- admin-gateway 后台管理
                String tokenStr = nativeWebRequest.getHeader(JWTConstance.TOKEN_INFO);
                if (!StringUtils.isEmpty(tokenStr)) {
                    String userInfo = JWTUtil.getUserInfo(tokenStr);
                    if (!StringUtils.isEmpty(userInfo)) {
                        TokenUserInfo tokenUserInfo = JSON.parseObject(userInfo, TokenUserInfo.class);
                        tokenUserInfo.setToken(tokenStr);
                        return tokenUserInfo;
                    } else {
                        throw new Exception("参数解析器：获取token信息失败");
                    }
                }
            } else if ("public-gateway".equals(sourceGateway)) { // -------------------------------- public-gateway C端程序访问入口
                String tokenStr = nativeWebRequest.getHeader(JWTConstance.TOKEN_INFO);
                CorpAppToken token = tokenManager.parseToken(tokenStr);
                if (methodParameter.getParameterType().isAssignableFrom(WechatProgramUser.class)) {
                    return tokenManager.getWechatProgramUserInfo(token.getAppCode(), token.getWxUserId());
                } else if (methodParameter.getParameterType().isAssignableFrom(CorpAppToken.class)) {
                    return token;
                }
            }

            return null;
        }

        if (methodParameter.hasParameterAnnotation(CurrentSKey.class)) {
            String sKey = nativeWebRequest.getHeader("sKey");
            String sKeyInfoJsonStr = sKeyManager.getSkeyInfo(sKey);
            SkeyInfo skeyInfo = new SkeyInfo();
            if (!StringUtils.isEmpty(sKeyInfoJsonStr)) {
                skeyInfo.setUnionId(JSON.parseObject(sKeyInfoJsonStr).getString("unionid"));
                skeyInfo.setSessionKey(JSON.parseObject(sKeyInfoJsonStr).getString("session_key"));
                skeyInfo.setOpenId(JSON.parseObject(sKeyInfoJsonStr).getString("openid"));
                skeyInfo.setSkeyUrl(sKey);
            } else {
                throw new Exception("参数解析器：获取Skey信息失败");
            }
            return skeyInfo;
        }
        return null;
    }
}

java 超级关键字

用于访问父类的成员。

super.java

@Override
public int getSalary()
{
    return super.getSalary();           // Returns parent class' salary instead of child
}

java Java中的Getters和Setter

getset.java

public class abc
{
    private int z;

    public int getZ() {
        return z;
    }

    public void setZ(int z) {
        this.z = z;
    }
}

main()
{
    System.out.println("Hello World");
    MyClass x = new MyClass();
    x.setZ(5);
    int a = x.getZ();
}

java 用户输入

plaintext.java

// Inside OnClick

String s = plainText.getText().toString();
showText.setText("Your name is " + s);

java 按键

button.java

import android.widget.*;

// In Main Activity 
private Button x;           // Create object of Button class

// In onCreate
x = findViewById(R.id.button);      // Link object to existing button

// On Clicking the Button, Activity to be performed...
myButton.setOnClickListener
(
    new View.OnClickListener() 
    {
        @Override
            public void onClick(View view) 
            {
                // ...Goes Here
                showText.setText("This button was pressed.");
            }
    }
);


OR

// In Activity_Main.xml , under button add

android:onClick="abc"

// in Java File, add outside OnCreate()

public void abc(View s)
    {

    }
    
OR

// Using Interface

o1.setOnClickListener(this);        // Error comes. Click Lightbulb and second option and click OK

java 数组中查找和为特定值的两个元素

数组中查找和为特定值的两个元素

Test.java

package com.darwin.pikachu.example;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.ArrayTable;
import com.google.common.collect.Table;

import java.util.*;

public class Test {

    public static void main(String[] args) {
        int[] a = new int[]{2,7,11,15};
        int[] result = sum(a,9);
        int[] ints = sum2(a, 9);
        System.out.println(JSON.toJSON(result));
        System.out.println(JSON.toJSON(ints));
    }

    /**
     * 数组中查找和为num的两个
     * @param a
     * @param num
     * @return
     */
    public static int[] sum(int[] a, int num) {
        for (int i = 0; i < a.length; i++) {
            int t = num - a[i];
            for (int j = i + 1; j < a.length; j ++) {
                if (t == a[j]) {
                    int[] result = new int[]{i, j};
                    return result;
                }
            }
        }
        return null;
    }

    /**
     * 数组中查找和为num的两个
     * @param a
     * @param num
     * @return
     */
    public static int[] sum2(int[] a, int num) {
        Map<Integer, Integer> indexMap = new HashMap<>();
        for (int i = 0; i < a.length; i++) {
            int t = num - a[i];
            if (indexMap.containsKey(t)) {
                return new int[]{i, indexMap.get(t)};
            }
            indexMap.put(a[i], i);
        }
        return null;
    }

}

java Kruskals MST

#KRUSKAL MINIMUM SPANNING TREE *从节点到每个其他节点只有一条独占路径。 *子图具有所有此类子图中的最小总权重（所有边的总和）。 *没有形成周期 >策略是使每次使用最低边缘的不相交集增长。 关键：我们使用*** parents ***数组。父阵列中的每个槽代表为每个节点形成的组的代表节点。

kruskalMinSpanningTree.java

public class KruskalMST {
    // Finds the REPRESENTING NODE for vertex i 
    static int find(int i, int[] parent) 
    { 
        while (parent[i] != i) 
            i = parent[i]; 
        return i; 
    } 
    
    // Does union of i and j. 
    static void union1(int i, int j, int[] parent) 
    { 
        //find representatives of;
        //i --> a 
        //and
        //j --> b
        int a = find(i, parent); 
        int b = find(j, parent); 
        //make the representative of a point to representative of j
        parent[a] = b; 
    } 
    
    // Finds MST using Kruskal's algorithm 
    static int kruskalMST(int cost[][]) 
    { 
      int V = cost.length; 
      int[] parent = new int[V]; 
      int INF = Integer.MAX_VALUE; 

      int mincost = 0; // Cost of min MST. 
  
      // Initialize sets of disjoint sets. 
      for (int i = 0; i < V; i++) 
          parent[i] = i; 
  
      // Include minimum weight edges one by one 
      int edge_count = 0; 
      while (edge_count < V - 1) 
      { 
          int min = INF, a = -1, b = -1; 
          for (int i = 0; i < V; i++) 
          { 
              for (int j = 0; j < V; j++)  
              { 
                  if (find(i, parent) != find(j, parent) && cost[i][j] < min)  
                  { 
                      min = cost[i][j]; 
                      a = i; 
                      b = j; 
                  } 
              } 
          } 
          union1(a, b, parent);
          edge_count++;
          mincost += min; 
      } 
      return mincost;
    } 
  }
}

java 判断子序列问题

给定两个字符串吨和S，判断小号是否是吨的子串，是采用KMP算法。而判断小号是否是吨的子序列，有简单的方法和复杂的方法。复杂的方法就是回溯法，采用的Hashmap先来得到吨中每一个字符及其出现的位置的对应关系，然后递归顺序检测小号中每一个字符是否出现在吨中并且出现的位置是否合规。

dfs-bfs

public static boolean isSubseq(String t,String s) {
		//判断t是否是s的子序列
		if(t==null) return true;
		if(t.length()==1 && s.contains(t)) return true;
		Map<Character,List> map = new HashMap<>();
		for(int i = 0 ; i < s.length(); i++) {
			if(map.get(s.charAt(i))==null)
				map.put(s.charAt(i), new ArrayList<Integer>());
			map.get(s.charAt(i)).add(i);
		}
		boolean res = isSubseqRecurse(t,s,map,0,-1);
		return res;
	}
	public static boolean isSubseqRecurse(String t,String s,Map<Character,List> map,int cur_pos,int last_pos) {
		if(cur_pos==t.length())
			return true;
		
		List<Integer> list = map.get(t.charAt(cur_pos));
		if(list==null) return false;
		boolean flag = false;
		for(int i = 0 ;  i < list.size(); i++) {
			int cur = list.get(i);
			if(cur<=last_pos) continue;
			else flag |= isSubseqRecurse(t,s,map,cur_pos+1,cur);
		}
		return flag;
	}

java 菜单处理程序

main.java

package me.kodysimpson.inventoryguiplugin;

import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;

public class MenuHandler implements Listener {

    @EventHandler
    public void onMenuClick(InventoryClickEvent e){
        Player p = (Player) e.getWhoClicked();
        if (e.getView().getTitle().equalsIgnoreCase("How should I kill him?")){
            e.setCancelled(true);
            if (e.getCurrentItem() == null){
                return;
            }else if (e.getCurrentItem().getType().equals(Material.CHIPPED_ANVIL)){
                p.sendMessage("You want to slice someone! Nice!");
                p.closeInventory();
            }else if (e.getCurrentItem().getType().equals(Material.CYAN_CARPET)){
                p.sendMessage("You want to explode him! OKay!");
                p.closeInventory();
            }
        }
    }

}