一些小技巧
这些技巧对于单独的答案来说有点太小了，因此我将把这个答案用于我发现或想出的非常小的代码高尔夫技巧，而其他技巧尚未提及：
删除字符串的最后一个字符：
// I used to do something like this:
s.substring(0,s.length()-1) // 27 bytes
// But this is shorter:
s.replaceAll(".$","") // 21 bytes
在某些情况下，您事先知道最后一个字符是什么，并且您也知道此字符在字符串中仅出现一次。在这种情况下，您可以.split改用：
// As example: "100%" to "100"
s.split("%")[0] // 15 bytes
编码快捷方式：
// When you want to get the UTF-8 bytes I used to do this:
s.getBytes("UTF-8"); // 20 bytes
// But you can also use "UTF8" for the same result:
s.getBytes("UTF8"); // 19 bytes
所有编码都有java.nioAPI中使用的规范名称，以及java.io和java.langAPI中使用的规范名称。这是Java中所有受支持的编码的完整列表。因此，请始终使用两者中最短的一个。第二个通常较短（如UTF-8vs utf8，Windows-1252vs Cp1252等），但并不总是较短（UTF-16BEvs UnicodeBigUnmarked）。
随机布尔值：
// You could do something like this:
new java.util.Random().nextBoolean() // 36 bytes
// But as mentioned before in @Geobits' answer, Math.random() doesn't require an import:
Math.random()<.5 // 16 bytes
素数：
检查素数或获得所有素数的方法有很多，但是@SaraJ的答案是最短的。以下是复制粘贴作为参考：
// Check if n is a prime:
n->{int i=1;for(;n%++i%n>0;);return n==i;}
// Which can easily be modified to loop through primes:
v->{for(int n=2,i;;){for(i=1;n%++i%n>0;);if(n++==i)/*do something with prime `i` here*/;}}
注意：通常，您可以根据要使用的方式将其与其他现有循环合并，因此不需要单独的方法。例如，这在此答案中节省了大量字节。
整数截断而不是Math.floor / Math.ceil：
如果您要使用正双精度数/浮点数并且想要使用floor它们，请不要使用Math.floor而是使用(int)-cast（因为Java在整数上截断）：
double d = 54.99;
int n=(int)Math.floor(d); // 25 bytes
int m=(int)d; // 13 bytes
// Outputs 54 for both
可以将相同的技巧应用于负双打/浮动，ceil而不是：
double d = -54.99;
int n=(int)Math.ceil(d); // 24 bytes
int m=(int)d; // 13 bytes
// Outputs -54 for both
使用&1代替%2来消除括号：
由于运算符优先级的&比默认的算术运算符类似的低级*/+-和%，你可以摆脱在某些情况下的括号。
// So instead of this:
(i+j)%2 // 7 bytes
// Use this:
i+j&1 // 5 bytes
请注意，这在布尔检查中并没有真正的帮助，因为那时您仍然需要括号，它们只是稍微移动了一点：
(i+j)%2<1 // 9 bytes
(i+j&1)<1 // 9 bytes
BigIntegers并为静态方法调用创建变量：
使用BigIntegers时，只需创建一次即可，然后可以重复使用。正如你可能知道，BigInteger的包含静态字段ZERO，ONE和TEN。因此，当您仅使用这三个时，就不需要使用，import而是可以java.Math.BigInteger直接使用。
// So instead of this:
import java.math.BigInteger.*;
BigInteger a=BigInteger.ONE,b=BigInteger.ZERO; // 76 bytes
// or this:
java.math.BigInteger a=java.math.BigInteger.ONE,b=a.ZERO; // 57 bytes
// Use this:
java.math.BigInteger t=null,a=t.ONE,b=t.ZERO; // 45 bytes
注意：您必须使用=nullso t进行初始化才能使用t.。
有时，您可以添加多个BigIntegers来创建另一个以节省字节。因此，假设您1,10,12出于某种原因希望拥有BigIntegers ：
// So instead of this:
BigInteger t=null,a=t.ONE,b=t.TEN,c=new BigInteger(12); // 55 bytes
// Use this:
BigInteger t=null,a=t.ONE,b=t.TEN,c=b.add(a).add(a); // 52 bytes
正如注释中正确指出的那样，BigInteger t=null;静态方法调用的技巧也可以与其他类一起使用。
例如，以下是2011年的答案：
// 173 bytes:
import java.util.*;class g{public static void main(String[]p){String[]a=p[0].split(""),b=p[1].split("");Arrays.sort(a);Arrays.sort(b);System.out.print(Arrays.equals(a,b));}}
// 163 bytes
class g{public static void main(String[]p){java.util.Arrays x=null;String[]a=p[0].split(""),b=p[1].split("");x.sort(a);x.sort(b);System.out.print(x.equals(a,b));}}
getBytes() 代替 toCharArray()
当您想遍历字符串的字符时，通常会这样做：
for(char c:s.toCharArray()) // 27 bytes
// or this:
for(String c:s.split("")) // 25 bytes
在打印字符或将其附加到字符串或类似内容时，循环遍历字符可能很有用。
但是，如果你只使用一些Unicode的数量计算的字符，你可以替换char使用int，并且可以替换toCharArray()使用getBytes()：
for(int c:s.getBytes()) // 23 bytes
甚至在Java 8+中更短：
s.chars().forEach(c->...) // 22 bytes
在Java 10+中，现在可以以22个字节为单位循环打印字符：
for(var c:s.split("")) // 22 bytes
来自的随机项目List：
List l=...;
// When we have an `import java.util.*;` in our code, shuffling is shortest:
return l.get(new Random().nextInt(l.size())); // 45 bytes
return l.get((int)(Math.random()*l.size())); // 44 bytes
Collections.shuffle(l);return l.get(0); // 39 bytes
// When we don't have an `import java.util.*` in our code, `Math.random` is shortest:
return l.get(new java.util.Random().nextInt(l.size())); // 55 bytes
return l.get((int)(Math.random()*l.size())); // 44 bytes
java.util.Collections.shuffle(l);return l.get(0); // 49 bytes
检查字符串是否包含前导/尾随空格
String s=...;
// I used to use a regex like this:
s.matches(" .*|.* ") // 20 bytes
// But this is shorter:
!s.trim().equals(s) // 19 bytes
// And this is even shorter due to a nice feature of String#trim:
s!=s.trim() // 11 bytes
当!=在Strings上检查引用而不是Java中的值时，为什么这样做有效？因为String#trim将返回“ 此字符串的副本，其中删除了前导和尾随空白，如果没有前导或尾随空白，则返回此字符串。 ”在有人向我建议之后，在我的这个答案中，我使用了它。
回文：
要检查一个字符串是否是回文（记住字符串的偶数和奇数长度），这是最短的（.contains在这里起作用，因为我们知道字符串本身及其反向形式的长度是相等的）：
String s=...;
s.contains(new StringBuffer(s).reverse()) // 41 bytes
.contains(...)而不是.equals(...+"")感谢@assylias在这里的评论。
要么是0，要么都是0？
我想大多数已经知道这一个：如果您要检查如果任一a或者b是零，而不是乘救字节：
a==0|b==0 // 9 bytes
a*b==0 // 6 bytes
而且，如果要检查两个a和b是否均为零，则可以使用按位或，或者如果它们始终为正，则将它们加在一起：
a==0&b==0 // 9 bytes
(a|b)==0 // 8 bytes (if either `a`, `b` or both can be negative)
a+b<1 // 5 bytes (this only works if neither `a` nor `b` can be negative)
偶数= 1，奇数= -1; 或相反亦然
// even = 1; odd = -1:
n%2<1?1:-1 // 10 bytes
1-n%2*2 // 7 bytes
// even = -1; odd = 1:
n%2<1?-1:1 // 10 bytes
n%2*2-1 // 7 bytes
我添加这个的原因是k+(k%2<1?1:-1)在这个答案中看到之后：
k+(k%2<1?1:-1) // 14 bytes
// This would already have been shorter:
k%2<1?k+1:k-1 // 13 bytes
// But it can also be:
k%2*-2-~k // 9 bytes
n完整程序中的循环时间
如果在强制执行完整程序的过程中遇到挑战，并且需要循环特定的时间，则可以执行以下操作：
// instead of:
interface M{static void main(String[]a){for(int n=50;n-->0;)/*do something*/}} // 78 bytes
// we could do:
interface M{static void main(String[]a){for(M m:new M[50])/*do something*/}} // 76 bytes
当我们必须将此范围用作输入时，同样适用：
interface M{static void main(String[]a){for(int n=new Byte(a[0]);n-->0;)/*do something*/}} // 90 bytes
interface M{static void main(String[]a){for(M m:new M[new Byte(a[0])])/*do something*/}} // 88 bytes
感谢@JackAmmo在此评论。
返回时以及何时使用它时，尝试使用try-finally而不是try-catch（Exception e）
如果您不能使用a，throws Exception但必须catch在返回之前对其进行处理，则可以finally改用：
try{...}catch(Exception e){return ...;} // 33 bytes
try{...}finally{return ...;} // 22 bytes
至于何时使用a的示例try-catch，我可以参考我的答案（间接高尔夫球场的积分去@KamilDrakari）。在此挑战中，我们必须在NxM矩阵上对角循环，因此我们必须确定列数或行数是否为for循环中的最小值或最大值（以字节为单位，这是非常昂贵的：）i<Math.min(a.length,a[0].length)。因此，仅捕获ArrayIndexOutOfBoundsException使用catch-finally情况比此检查要短，从而节省了字节：
int[] a = ...;
int r=0,i=0;for(;i<Math.min(a.length,a[0].length);)r=...i++...;return r; // 66 bytes
int r=0,i=0;try{for(;;)r=...i++...;}finally{return r;} // 48 bytes
注意：这仅是因为return r;最后的才起作用。建议我修改第一个单元格，就像@KamilDrakari在他的C＃答案中所做的那样以保存字节。但是，在Java中，这意味着我将不得不将其更改为m->{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch(Exception e){}}（73个字节），实际上增加了字节数，而不是如果可以使用则减少了字节数finally。
Math.pow（2，n）
当您想要2的幂时，按位计算的方法要短得多：
(int)Math.pow(2,n) // 16 bytes
(1<<n) // 6 bytes
结合按位和逻辑检查，而不使用括号
我认为这是现在众所周知的&，并|可以用来代替&&和||中爪哇（布尔）逻辑检查。在某些情况下，您仍然想使用&&而不是&防止错误，例如index >= 0 && array[index].doSomething。如果&&将更改为&此处，它将仍然评估在数组中使用索引的部分，从而导致ArrayIndexOutOfBoundsException，因此&&在这种情况下使用代替&。
到目前为止，Java 中&&/ ||vs &/ 的基础知识|。
当您想检查时(A or B) and C，最短的似乎使用了如下的按位运算符：
(A|B)&C // 7 bytes
但是，由于按位运算符的优先级高于逻辑检查，因此您可以将两者合并以在此处保存一个字节：
A|B&&C // 6 bytes
使用n+=...-n代替(long)...
例如，当使用lambda时，输入和输出中都有一个长Math.pow字符时，可以使用n+=...-n代替来保存一个字节(long)...。
例如：
n->(long)Math.pow(10,n) // 23 bytes
n->n+=Math.pow(10,n)-n // 22 bytes
这在保存一个字节这样的回答我的，并结合甚至两个字节-n-1来+~n在这个答案我的。
package可以跳过。