1. 首页
  2. 代码片断库
  3. java
全部数据
text
javascript
php
markdown
sh
java
python
html
csharp
css
sql
c_cpp
PHP
ruby
xml
scss
json
swift
JavaScript
typescript
vbscript
powershell
CSS
apache_conf
ActionScript 3
r
ini
HTML
golang

java Hello World for Java

HelloWorld.java 
public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, World");
  }
}

java LCS / LIS / LCIS

最长递增子序列，最大连续子序列和，最大连续子序列乘积，最长公共子序列，最长公共子串

Longest incremental subSeq 
//最长递增子序列
//DP,dp[i]表示以nums[i]结尾的子序列中递增子序列的最大长度，所以dp[i]=max{dp[j]+1} if nums[j]<=nums[i],0=<j<i
public int LIS(int[] nums){
  int [] dp = new int [nums.length]{1};
  for(int i = 1;i < nums.length;i++){
    for(int j = 0; j < i; j++){
      if(nums[j] <= nums[i]) dp[i] = max(dp[j]+1,dp[i]);
    }
  }
  int res = 0;
  for(int i = 0 ; i < dp.length; i++){
    res = max(res,dp[i]);
  }
  return res;
}
max consecutive subSeq sum 
//最大连续子序列和
//DP,dp[i]表示以i为止数值结尾的最大连续子序列和，如果dp[i]<0则dp[i]=nums[i],否则dp[i]=dp[i-1]+nums[i]，也就是说dp[i]=max{nums[i],dp[i-1]+nums[i]}
public int maxConsecutiveSubsetSum(int[] nums){
  int[] dp= new int[nums.length];
  dp[0]=nums[0];
  for(int i =1 ; i < nums.length; i++){
    dp[i]=Math.max(nums[i],dp[i-1]+nums[i]);
  }
  int res = Integer.MIN_VALUE;
  for(int i = 0 ; i < nums.length; i++){
    res = Math.max(dp[i],res);
  }
  return res;
}
max consecutive sebseq sum II 
//最大连续子序列和问题，可以用上面的DP，也可以用分治算法，时间复杂度O(nlogn)。
public int maxSubseqSum(int [] nums){
  if(nums==null || nums.length==0) return 0;
  return maxSubseqSumHelper(nums,0,nums.length-1);
}
public int maxSubseqSumHelper(int[] nums,int left,int right){
  if(left==right) return nums[left];
  int left_mss = maxSubseqSumHelper(nums,left,(left+right)/2);
  int right_mss = maxSubseqSumHelper(nums,(left+right)/2+1,right);
  
  int mid_to_left = Integer.MIN_VALUE,mid_to_right=Integer.MIN_VALUE;
  int sum = 0 ;
  for(int i = mid; i >= left; i--){
    sum = sum+nums[i];
    mid_to_left = Math.max(mid_to_left,sum);
  }
  sum =  0;
  for(int i = mid+1;i <= right; i++){
    sum = sum+nums[i];
    mid_to_right = Math.max(mid_to_right,sum);
  }
  
  int result = Math.max(left_mss,right_mss);
  return Math.max(res,mid_to_left+mid_to_right);
}
max product of consecutive subset 
//最大连续子序列乘积
//DP,但是由于需要是连续的，而且乘积尽量大的话可以前面最小的负值积和一个负值相乘得到，或者前面最大的正值和一个正值相乘得到。
public int maxProductConsecutiveSubset(int[] nums){
  int [] min_val = new int[nums.length];
  int [] max_val = new int[nums.length];
  maxdp[0]=mindp[0]=nums[0];
  for(int i = 1; i < nums.length;i++){
    maxdp[i] = Math.max(nums[i],maxdp[i-1]*nums[i],mindp[i-1]*nums[i]);
    mindp[i] = Math.min(nums[i],maxdp[i-1]*nums[i],mindp[i-1]*nums[i]);
  }
  int res = Integer.MIN_VALUE;
  for(int i = 0 ; i < maxdp.length; i++){
    if(maxdp[i] > res) res=maxdp[i];
  }
  return res;
}
longest common subseq 
//最长公共子序列问题
//二维DP来求解，设定dp[i][j]代表第一个字符串到第i个字符为止和第二个字符串到第j个字符为止最大的公共子序列
//如果s[i]=t[j]则dp[i][j]=dp[i-1][j-1]+1，否则dp[i][j]=max{dp[i][j-1],dp[i-1][j]},其中dp[i][0]=dp[0][j]=0
public static int lcs(String str1,String str2){
		int len1 = str1.length();
		int len2 = str2.length();
		int[][] c = new int[len1+1][len2+1];
		for(int i = 0 ;i <= len1;i++){
			for(int j = 0 ; j <= len2;j++){
				if(i==0 || j==0)
					c[i][j]=0;  //初始值设定
				else if(str1.charAt(i-1)==str2.charAt(j-1))//这里的i指的是字符串第i个字符，i-1指的是i-1索引处的字符
					c[i][j] = c[i-1][j-1]+1;
				else
					c[i][j] = Math.max(c[i-1][j],c[i][j-1]);
			}
		}
		return c[len1][len2];
	}

java leetcode--查找递增三元子序列

DP：设定DP []表示我位置之前包括我位置小于等于NUMS [I]的值的个数，所以对于我位置，遍历0 <= j的<= I，DP [I] = MAX（DP [I ]，dp [j] +1）如果nums [j] <= nums [i]。<br/>双数组法：建立两个数组pre [] && post []，pre数组保存0-i之间最小的数，交数组保存在-1之间最大的数。如果发现有预[I] <NUMS [I] <交[I]则说明存在

dp 
public boolean threeIncrementalSeries(int [] nums){
  int[] dp =  new int[nums.length]{1};
  for(int i = 1; i < nums.length; i++){
    for(int j = 0 ; j <=i ;  j++){
      if(nums[i] >= nums[j]) dp[i] = Math.max(dp[i],dp[j]+1);
      if(dp[i] >= 3) return true;
    }
  }
  return false;
}
Double Array 
public boolean threeIncrementalSeq(int[] nums){
  int[] pre = new int[nums.length];
  int[] post = new int[nums.length];
  post[nums.length-1]=pre[0]=-1;
  int min_pre=Integer.MAX_VALUE,max_post = Integer.MIN_VALUE;
  for(int i = 1; i < nums.length; i++){
    min_pre = min(min_pre,nums[i]);
    pre[i]=min_pre;
  }
  for(int i = nums.length-2; i >=0; i--){
    max_post= max(max_post,nums[i]);
    post[i]=max_post;
  }
  for(int i=1; i < nums.length-1;i++){
    if(nums[i] > pre[i] && nums[i] < post[i])
      return true;
  }
  return false;
}

java 在有序矩阵中搜索

searchMatrix 
/*
Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted in ascending from left to right.
Integers in each column are sorted in ascending from top to bottom.
*/

 public boolean searchMatrix(int[][] matrix, int target) {
        
        //ERROR CHECK:
        
        //Matrix empty
            if(matrix.length == 0 || matrix[0].length == 0) return false;
        //Target not in matrix
            int rows = matrix.length;
            int columns = matrix[0].length;
            if(target < matrix[0][0] || target > matrix[rows-1][columns-1]) return false;
        
        int row = rows-1;
        int column = 0;
        
        while(row >= 0 && column < columns){
            if(matrix[row][column] == target) return true;
            else if(matrix[row][column] > target) row--;
            else column ++;
        }
        
        return false;    
    
    }
    
    
/*
 Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.
*/

 public boolean searchMatrix(int[][] matrix, int target) {
     
        if(matrix.length == 0 || matrix[0].length == 0) return false;
        
        int row = 0;
       
        while(row < matrix.length && matrix[row][0] <= target){
            if(matrix[row][0] == target) return true;
            row++;
        }
        
        if(row == 0) return false;
        
        if(Arrays.binarySearch(matrix[row-1], target) >= 0) return true;
        else return false;
        
    }

java Stanfort QuickSort

quick 
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;

public class quickSortComparisons {
	
	public static class Comparisons{
		long count;
		
		public Comparisons() {
			count = 0;
		}
	}
	
	 public static void quickSort(int[] array){
		 	Comparisons comparisons = new Comparisons();
		    quickSort(array, 0, array.length-1, comparisons);
		    System.out.println(comparisons.count);
		  }
		 
		  public static void quickSort(int[]array, int left, int right, Comparisons c){
		    if(left >= right){
		      return;
		    }
		 
		    int index = partition(array, left, right, c);
		    
		    quickSort(array, left, index-1, c);
		    quickSort(array, index+1, right, c);
		  }
		 
		  public static int partition(int[] array, int left, int right, Comparisons c){
			  
			  c.count += right - left;

			int index = pivotChoser(array, left, right,(right+left)/2);
			swap(array, left, index); //put the pivot at the beginning of the array
			int pivot = array[left];
			
			int i = left+1;
			for (int j= left+1; j<=right; j++) {
				if(array[j] < pivot) {
					swap(array, i, j);
					i++;
				}
			}
			
			swap(array, left, i-1);
			return i-1;
			
		  }
		  
		  public static int pivotChoser(int[] array, int left, int right, int middle) {
	
			
			  int[] temp = new int[3];
			  
			  temp[0] = array[left];
			  temp[1] = array[middle];
			  temp[2] = array[right];
			  
			  for(int i=0; i<temp.length; i++) {
				  for(int j=0; j<temp.length-1; j++) {
					  if(temp[i]<temp[j])swap(temp, i, j);
				  }
			  }
			  
			  if(temp[1] == array[left])return left;
			  if(temp[1] == array[middle])return middle;
			  else return right;
			  
		  }
		  
		  public static void swap(int[]a, int left, int right) {
			  int e = a[left];
			  a[left] = a[right];
			  a[right] = e;
		  }

	public static void main(String[] args) throws NumberFormatException, IOException {
		

		
		int[] arr = new int[10000];
		
		
		BufferedReader abc = new BufferedReader(new FileReader("quick.txt"));
		int i=0;
		String line = "";
		while((line = abc.readLine()) != null) {
		    arr[i] = Integer.parseInt(line);
		    i++;
		}
		abc.close();

		quickSort(arr);
		
		boolean sorted = true;
		for(int x=0; x<arr.length-1; x++) {
			if(arr[x]>arr[x+1])sorted = false;
		}
		
		System.out.println("HA FUNCIONADO: "+ sorted);

		
		System.out.println(Arrays.toString(arr));
	} 

}

java Tworzenie我操纵实体

main.java 
player.getWorld().spawnEntity(player.getLocation(), EntityType.TURTLE);

java Rejestrowanie eventu

main.java 
getServer().getPluginManager().registerEvents(new EventMove(), this);

java Metodaprzyjmującagraczajako论点

main.java 
private void flyMethod(Player player) {
    if(player.hasPermission("flyplugin.fly")) {
        if(!listOfFlyingPlayers.contains(player)) {
            player.setAllowFlight(true);
            listOfFlyingPlayers.add(player);
            player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("fly-on")));
        } else {
            player.setAllowFlight(false);
            listOfFlyingPlayers.remove(player);
            player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("fly-off")));
        }
    }
}

java LeetCode - 大多数水的容器

给一个数组表示第我位置的竖线是A [1]，不是杆而是竖线所以装水的时候不会占用体积。求某个两条竖线之间装水装的最多的量。

leetcode 
//可以用双指针i和J,分别从两头开始，小的往里滑动。
public int containerMostWater(int [] nums){
  int res = 0 ,i=0,j=nums.length-1;
  while(i < j){
    res = Math.max(res,(j-i)*Math.min(nums[i],nums[j]));
    if(nums[i] < nums[j]) i++;else j--;
  }
  return res;
}

java Komenda z targetem na gracza

main.java 
package me.landu.argumenty.Commands;

import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

public class Kill implements CommandExecutor {

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {

        if(sender instanceof Player) {
            Player player = (Player) sender;
            if(args.length == 0) {
                player.sendMessage("Zabiłeś się");
                player.setHealth(0);
            } else if(args.length == 1) {
                Player target = Bukkit.getPlayerExact(args[0]);
                if(target instanceof Player) {
                    target.sendMessage("Zostałeś zabity przez " + player.getDisplayName());
                    target.setHealth(0);
                    player.sendMessage("Zabiłeś" + target.getDisplayName());
                } else {
                    player.sendMessage("Argument nie jest graczem");
                }
            }

        }

        return true;
    }
}