Java에서 사용할 수있는 유용한 단축키가 있습니까?

아래에 표시된 것처럼 import이미 프로그램에 17 자 이상을 추가합니다.

import java.io.*;

간단한 해결책은 다른 언어를 사용하는 것이지만 Java 프로그램을 단축하는 것은 어려운 일인 것 같습니다.

팁은 Java에만 적용되어야합니다. 대부분의 C와 유사한 언어에 적용 할 수있는 경우 더 일반적인 팁 목록에 속합니다 .

• 가장 최근에 가능한 Java를 사용하십시오. Java 8에서는 람다 식을 사용할 수 있으므로 기능적 객체 와 같은 것이 필요한 경우이를 사용하십시오 .

• 많이 사용하는 것들에 대해 단축 된 기능을 정의하십시오. 예를 들어에 대한 백 번의 호출이 exampleClassInstance.doSomething(someParameter)있고 새로운 기능을 정의한 후 void d(ParameterType p){exampleClassInstance.doSomething(p)}이를 사용하여 일부 문자를 저장합니다.

• 특정 긴 클래스 이름을 두 번 이상 사용하는 경우

  MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory

  대신 새 클래스를 정의하십시오.

  class X extends MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory{}

  해당 클래스의 특정 메소드를 하나만 사용하고 있지만 인스턴스화해야하는 경우 새 클래스 내에서 단축 버전을 동시에 정의 할 수 있습니다.

• 가능한 경우 함수 유형 매개 변수를 사용하여 항목을 줄이십시오.

  <T>void p(T o){System.out.println(o);}

• for(;;)대신에 사용하십시오 while(true).

• 꼭 필요한 경우가 아니면 액세스 수정자를 사용하지 마십시오.

• final아무것도 사용하지 마십시오 .

• for루프 뒤에 블록을 두지 마십시오 (그러나 foreach 루프 for(x:y)는 다릅니다). 추가 명령문은 다음 for과 같이 명령문 자체 내에 배치해야합니다 for(int i=0;i<m;a(i),b(++i))c(i);.

• 인라인 할당, 증분, 인스턴스화를 사용하십시오. 적절한 경우 익명 인라인 클래스를 사용하십시오. 가능한 경우 람다를 대신 사용하십시오. 중첩 함수 호출. 일부 기능은 부모 개체를 반환 보장,이 사람은 실제로도하는 의미가 서로 연결되어야한다.

• 당신의 main방법 throws Exception은 그들을 잡을 수 없습니다.

• Error보다 짧습니다 Exception. 어떤 이유로 당신이 경우 정말 필요 throw스택 메시지까지,를 사용하는 Error것이 지극히 정상적인 상황 인 경우에도.

• 어떤 조건에서 즉시 종료해야하는 int a=1/0;경우 throw null;또는 대신을 사용하십시오 System.exit(0);. 런타임시 ArithmeticException. 코드에 이미 숫자 변수가있는 경우 대신 변수를 사용하십시오. (이미있는 import static java.lang.System.*;경우으로 이동하십시오 exit(0);.)

• 와 같은 인터페이스를 구현하는 대신 List<E>, AbstractList<E>대부분의 메소드의 기본 구현을 제공하고 다음의 구현 만 요구하는 것과 같은 즉각적인 (또는 전혀 그렇지 않은 경우 즉각적이지 않은) 하위 클래스 를 확장하십시오. 몇 가지 중요한 부분.

• 줄 바꿈, 들여 쓰기 및 전체 변수 이름을 사용하여 코드를 먼저 작성하십시오. 작업 코드가 있으면 이름을 줄이고 선언을 이동하고 바로 가기 메서드를 추가 할 수 있습니다. 시작하기 위해 길게 작성하면 프로그램 전체를 단순화 할 수있는 기회가 더 많아집니다.

• 가장 최적화 된 전략은 코드를 아주 조금만 변경하면 크게 변경 될 수 있으므로 대체 최적화와 코드를 비교하십시오. 예를 들어 :

  • 에 대해 최대 두 번만 전화를 거는 Arrays.sort(a)경우 가장 효율적인 방법은 정규화 된 이름으로 전화하는 것입니다 java.util.Arrays.sort(a).
  • 세 번 이상 호출하면 바로 가기 방법을 추가하는 것이 더 효율적 void s(int[]a){java.util.Arrays.sort(a);}입니다. 이 경우에도 여전히 완전한 이름을 사용해야합니다. (두 개 이상의 과부하가 필요한 경우 잘못된 것일 수 있습니다.)
  • 그러나 코드가 특정 시점에 배열을 복사해야하는 경우 (일반적으로 for쉽게 액세스 할 수있는 라이브러리 방법이없는 경우 골프에서 짧은 루프로 수행됨) 작업을 수행 할 수 있습니다 Arrays.copyOf. 둘 이상의 메소드가 사용되고 3 개 이상의 호출 import static java.util.Arrays.*;이있는 경우 해당 메소드를 참조하는 가장 효율적인 방법입니다. 그 후, 8 개 이상의 개별 호출이있는 경우에만 sort단축기 방법 을 사용해야하며 5 개 이상의 호출에서만 보증되는 단축기가 필요합니다 copyOf.

  코드에서 이러한 분석을 수행하는 유일한 방법은 실제로 코드 사본에서 잠재적 인 수정을 수행 한 다음 결과를 비교하는 것입니다.

• someTypeValue.toString();방법을 사용하지 말고 대신 추가하십시오 someTypeValue+"".

• 윈도우가 필요하면 Swing을 사용하지 말고 AWT를 사용하십시오 (Swing에서 실제로 필요한 것이 아닌 한). import javax.swing.*;와 비교하십시오 import java.awt.*;. 또한 스윙 구성 요소가 한 J이름 (앞에 추가 JFrame, JLabel등)하지만 AWT의 구성 요소는하지 않습니다 ( Frame, Label, 등)

interface대신에 사용하십시오 class.

Java 8에서는 정적 메소드가 인터페이스에 추가되었습니다. 인터페이스에서 모든 메소드는 기본적으로 공용입니다. 따라서

class A{public static void main(String[]a){}}

이제 단축 될 수있다

interface A{static void main(String[]a){}}

분명히 더 짧습니다.

예를 들어, 내가 사용 이 기능 안녕하세요, 세상을! 도전.

varargs 를 사용하면 매개 변수를 동일한 유형의 배열로 "캐스트"할 수 있습니다.

void f(String...x){
    x=x[0].split("someregex");
    // some code using the array
}

대신에

void f(String s){
    String[]x=s.split("someregex");
    // some code using the array
}

A의 고정 수입 :

import static java.lang.System.out;
// even shorter (thanks to Johannes Kuhn):
import static java.lang.System.*;

나중에 상용구를 절약 할 수 있지만, 지불에 도달하려면 여러 번의 호출이 필요합니다.

public static void main (String[] args) {
    out.println ("foo");    
    out.println ("bar");    
    out.println ("baz");    
}

에 대한 인수를 호출 할 main필요는 없으며 args공백을 줄일 수 있습니다.

public static void main(String[]a){}

잘 될 것입니다.

부울 식 true또는 을 사용해야하는 경우에는 각각 false을 1>0및로 1<0바꿉니다.

예를 들면 다음과 같습니다.

boolean found=false;
for(i=0; i<10; i++) if(a[i]==42) found=true;

이 선형 검색 예제는

boolean f=1<0;
for(i=0;i<10;)if(a[i++]==42)f=1>0;

일부 메소드를 많이 사용하려는 경우 상주 클래스를 변수에 지정하십시오. 예를 들어 System.out변수에 할당 하십시오.

java.io.PrintStream o=System.out;
//now I can call o.print() or o.println() to the same effect as System.out.println()

또한 Integer.parseInt():

Integer i=1;
i.parseInt("some string");

이것은 거의 "변수에서 정적 메소드에 액세스"에 대한 ide 경고를 유발할 것입니다

문 import static java.lang.System.*을 저장 하는 기술을 사용하는 대신 println()다음 방법을 정의하면 문자를 저장하는 데 훨씬 효과적이라는 것을 알았습니다.

static<T>void p(T p){
    System.out.println(p);
}

이는 훨씬 빠르고 극적인 캐릭터 보상이 p(myString)아닌 호출 할 수 있기 때문 out.println(myString)입니다.

이것은 분명해 보이지만 일부 Math기능 에는 더 짧은 옵션이 있습니다.

a=Math.max(b,c);
a=b>c?b:c;

a=Math.min(b,c);
a=b<c?b:c;

a=Math.abs(b);
a=b<0?-b:b;

a=Math.round(b);
a=(int)(b+.5);          // watch for precision loss if it matters

필요한 경우 Integer.MAX_VALUE(2147483647)를 사용하십시오 -1>>>1. Integer.MIN_VALUE(-2147483648) 더 잘 작성되었습니다 1<<31.

인수 (또는 다른 문자열)에서 숫자 를 가져와야 하는 경우 일반적으로 다음과 같은 내용이 표시됩니다.

public static void main(String[]a){
    int n=Integer.valueOf(a[0]);
    ...
}

많은 경우에, 당신은하지 않습니다 필요 을 Integer. 많은 도전은 많은 수를 사용하지 않습니다. 이후 Short및 Byte을 모두 언 박스는 것 int, 더 적절한를 사용하는 valueOf()대신에하고 몇 바이트를 저장합니다.

실제 유지 변수를 int로서 int이 둘보다 짧은이기 때문에,하지만, byte및 short:

int n=Byte.valueOf(a[0]);

여러 숫자에 대해이 작업을 수행 해야하는 경우이 방법 과 결합 할 수 있습니다 .

Byte b=1;
int n=b.valueOf(a[0]),m=b.valueOf(a[1])...

를 사용하지 마십시오 public class. 주요 방법은 공개되어야하지만 클래스는 그렇지 않습니다. 이 코드는 작동합니다 :

class S{public static void main(String[]a){System.out.println("works");}}

공개 수업이 java S아니더라도 달리 실 수 있습니다 class S. ( 업데이트 : 이 팁을 쓸 때 Java 7을 사용하고있었습니다. Java 8에서는 기본 메소드가 인터페이스에 있어야합니다 . Java 5 또는 6에서는 기본 메소드가 열거 형이어야합니다 .)

많은 자바 프로그래머는 이것을 모른다! 비공개 클래스의 main에 대한 Stack Overflow 질문에 대한 답변의 약 절반은 main 메소드가 공개 클래스에 있어야한다고 잘못 주장합니다. 이제 당신은 더 잘 알고 있습니다. publicin을 삭제하고 public class7자를 저장하십시오.

작은 코드 골프 팁

이 팁은 분리 된 답변에 비해 너무 작기 때문에이 답변은 내가 찾거나 생각 해낸 매우 작은 코드 골프 팁에 사용되며 아직 다른 팁에서는 언급되지 않았습니다.

문자열의 마지막 문자 제거

// 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를 :

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

정적 메소드 호출을위한 BigInteger 및 변수 작성 :

BigInteger를 사용하는 경우 한 번만 작성한 다음 재사용 할 수 있습니다. 아시다시피, 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                  

참고 :를 사용하려면 =null을 (를 t) 초기화해야합니다 t..

때로는 여러 BigInteger를 추가하여 바이트를 절약하기 위해 다른 BigInteger를 추가 할 수 있습니다. 1,10,12어떤 이유로 BigInteger 를 원한다고 가정 해 봅시다 .

// 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

문자를 반복하면 문자를 인쇄하거나 문자열에 추가 할 때 유용 할 수 있습니다.

당신이 일부 유니 코드 번호 계산의 문자를 사용하는 경우, 당신은을 대체 할 수 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또는 b0 인지 확인 하려면 바이트를 저장하는 대신 곱하십시오.

a==0|b==0    // 9 bytes
a*b==0       // 6 bytes

그리고 당신이 모두 있는지 확인하려는 경우 a와 b제로, 당신은 비트 단위 OR를 사용할 수 있습니다, 또는 그들은 항상 긍정적 인 경우 함께 추가 :

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-catch (예외 e) 대신에 사용

를 사용할 수는 throws Exception없지만 catch돌아 오기 전에해야 할 일이 있으면 finally대신 사용할 수 있습니다 .

try{...}catch(Exception e){return ...;}    // 33 bytes
try{...}finally{return ...;}               // 22 bytes

를 사용하는 경우의 예를 들어 try-catch, 나는 이 대답을 참조 할 수 있습니다 (간접 골프의 신용은 @KamilDrakari 로갑니다 ). 이 도전에서 우리는 NxM 행렬에 대각선으로 반복해야하므로 열의 양 또는 행의 양이 for-loop에서 최대 값보다 가장 낮은 지 여부를 결정해야합니다 (바이트 측면에서 상당히 비쌉니다 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 &/ 의 기본 사항 |.

check하려는 (A or B) and C경우 가장 짧은 비트 연산자를 다음과 같이 사용하는 것처럼 보일 수 있습니다.

(A|B)&C    // 7 bytes

그러나 비트 연산자는 논리 검사 보다 연산자 우선 순위 여기에 바이트를 저장하기 위해 두 가지를 결합 할 수 있습니다.

A|B&&C     // 6 bytes

사용하다 n+=...-n대신(long)...

예를 들어를 사용할 때와 같이 람다에 길이가 있고 길이가 긴 경우 대신을 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에서 나의이 대답 .

입력이 필요없는 골프의 경우 정적 블록을 사용하고 기본 방법없이 잘 실행할 수 있으며 Java 6으로 컴파일하면됩니다.

public class StaticExample{
    static {
        //do stuff
    }
}

우리는 모두 비트 xor ( ^) 에 대해 알고 있지만 논리 xor이기도합니다.

따라서 (a||b)&&!(a&&b)단순히됩니다 a^b.

이제 xor를 사용할 수 있습니다.

또한 연산자 |와 & 작업도 연산자 우선 순위가 변경되었음을 기억하십시오.

을 사용할 필요는 없습니다 Character.toLowerCase(char c). 대신을 사용하십시오 (c|32). 대신에 Character.toUpperCase(char c)사용 (c&~32). 이것은 ASCII 문자로만 작동합니다.

문자열을 숫자로 변환

문자열을 숫자 값으로 변환하는 방법에는 여러 가지가 있습니다.

String s = "12";

ABC.parseABC :

Short.parseShort(s); // 20 bytes
Integer.parseInt(s); // 20 bytes
Long.parseLong(s);   // 18 bytes

ABC.valueOf :

Short.valueOf(s);    // 17 bytes
Integer.valueOf(s);  // 19 bytes
Long.valueOf(s);     // 16 bytes

ABC.decode :

// Note: does not work for numeric values with leading zeros,
// since these will be converted to octal numbers instead
Short.decode(s);     // 16 bytes
Integer.decode(s);   // 18 bytes
Long.decode(s);      // 15 bytes

새로운 ABC :

new Short(s);        // 13 bytes
new Integer(s);      // 15 bytes
new Long(s);         // 12 bytes

따라서 코드 골프의 경우 문자열을 숫자 값으로 변환 할 때 생성자를 사용하는 것이 가장 좋습니다.

동일하게 적용됩니다 Double; Float; 그리고 Byte.

이미 존재하는 프리미티브를 객체로 재사용 할 수있는 경우 항상 적용되는 것은 아닙니다.
예를 들어 다음과 같은 코드가 있다고 가정 해 봅시다.

// NOTE: Pretty bad example, because changing the short to int would probably be shorter..
//       but it's just an example to get the point across

short f(short i,String s){
  short r=new Short(s);  // 21 bytes
  ... // Do something with both shorts
}

.decode매개 변수를 객체로 다시 사용하여 더 짧은 생성자 대신 사용할 수 있습니다 .

short f(Short i,String s){   // Note the short parameter has changed to Short here
  short r=i.decode(s);   // 20 bytes
  ... // Do something with both shorts
}

사용하지 마십시오 Random!

일반적으로 임의의 숫자가 필요한 경우 Random끔찍한 방법입니다 *. Math.random()대신 사용하는 것이 훨씬 좋습니다 . 를 사용하려면 Random이 작업을 수행해야합니다 (가 필요하다고 가정 해 봅시다 int).

import java.util.*;
Random r=new Random();
a=r.nextInt(9);
b=r.nextInt(9);

이것을 다음과 비교하십시오.

a=(int)(Math.random()*9);
b=(int)(Math.random()*9);

과:

int r(int m){return(int)(Math.random()*m);}
a=r(9);
b=r(9);

첫 번째 방법은 41+15n문자를 사용합니다 ( n통화 횟수 임). 두 번째는 25n문자이고 세 번째는43+7n 입니다.

따라서 한두 번만 필요한 경우 인라인 Math.random()방법을 사용하십시오 . 세 개 이상의 통화의 경우 함수를 사용하여 저장합니다. 어느 하나가에 문자를 저장 처음 사용 이상 Random.

이미 Math.random()for를 double사용하고 있다면 네 번의 사용으로 다음을 가져 오는 것이 여전히 절약된다는 것을 기억하십시오.

double r(){return Math.random();}

33자인 경우 통화 할 때마다 10을 저장합니다. r()

최신 정보

정수가 필요하고 캐스팅을 절약하려면 캐스팅 하지 마십시오!할당 대신 작업을 수행하면 Java가 자동 전송됩니다. 비교:

a=(int)(Math.random()*9);
a=9;a*=Math.random();

^{* 예측 가능한 결과를 위해 PRNG를 시드하지 않는 한. 그럼, 나는 그 주위에 많은 방법을 보지 못합니다.}

이 '순수한'Java를 고려할 지 모르겠지만 처리 중입니다. 통해 초기 설정이 거의없는 프로그램을 만들 수 있습니다 (자동으로 완료 됨).

콘솔 출력의 경우 다음과 같은 간단한 것을 가질 수 있습니다.

println("hi"); //done

그래픽 출력의 경우 조금 더 :

void setup() {
  size(640,480);
}
void draw() {
  fill(255,0,0); //color used to fill shapes
  rect(50,50,25,25); //25x25 pixel square at x=50,y=50
}

귀국 단축

다음을 사용하여 문자열의 리턴 문을 바이트 단위로 줄일 수 있습니다.

return "something";

에

return"something";

그리고 괄호로 return 문을 시작하면 그들과 같은 일을 할 수 있습니다.

return (1+taxRate)*value;

에

return(1+taxRate)*value;

따옴표는 괄호처럼 간주됩니까? 나는 실제로 재미있게 AppleScript를 통해 이것을 선택했으며 언급 할 가치가 있다고 생각했습니다.

과학적 표기법을 사용하는 것을 두려워하지 마십시오

복식 또는 수레를 다루는 경우 숫자에 과학적 표기법을 사용할 수 있습니다. 따라서 쓰는 대신 1 바이트를 저장 double a=1000하도록 변경할 수 있습니다 double a=1e3.

int대신에 사용해보십시오boolean

어떤 경우에는 C 프로그램에서 수행 할 수있는 것과 유사하게 일반적으로 부울을 반환하는 메소드에서 정수 값을 반환하는 것이 더 짧다는 것을 알았습니다.

박쥐 int가 바로 4 바이트보다 짧습니다 boolean. 당신이 쓸 때마다 return 0대신은 return 1<0, 당신은 추가로 2 바이트에 동일한 저장 return 1 이상을 return 1>0.

함정은 반환 값을 부울로 직접 사용할 때마다 2 바이트 ( if(p(n))v. if(p(n)>0))의 비용이 든다는 것 입니다. 부울 산술을 사용하여 구성 할 수 있습니다. 당신이 쓰고 싶은 계획된 시나리오를 감안할 때

void a(int[]t){t[0]+=p(n)?10:0;}

대신 쓸 수 있습니다

void a(int[]t){t[0]+=p(n)*10;}

2 바이트를 절약하기 위해.

class 대신 enum 을 사용 하면 하나의 문자를 저장합니다.

enum NoClass {
    F, G, H;    
    public static void main (String[] args) {

    }
}

그러나 스스로 지불해야하는 하나 이상의 열거 형 인스턴스 (이 예에서는 F, G, H)를 소개해야합니다.

당신이 반환해야하는 방법이있을 때 boolean또는 Boolean, 즉 :

// Return true if the (non-negative) input is dividable by 5
boolean c(int i){return i%5<1;}

1 바이트를 저장 하도록 boolean/ Booleanreturn-type을 변경할 수 있습니다 Object.

Object c(int i){return i%5<1;}

또한 알다시피 바이트를 저장하는 <1대신 확인을 사용할 수 있습니다 ==0. 비록 Java 고유의 ​​것이 아니라 일반적인 코드 골프 팁입니다.
이것은 길이 확인과 같이 정수가 음수가 될 수 없을 때 주로 사용됩니다.

a.length<1

대신에

a.length==0

Java로 그리는 방법 ...

가장 짧은 GUI 페인트 보일러 플레이트는 다음과 같습니다.

import java.awt.*;
static void main(String[]x){
    new Frame(){
        public void paint(Graphics g){
            // Draw your stuff here.
        }    
    }.show();
}

111 바이트 골프 :

import java.awt.*;static void main(String[]x){new Frame(){public void paint(Graphics g){/*CodeHere*/}}.show();}

StringBuilders를 피하십시오

에 물건을 추가하는 String것은 훨씬 적은 바이트를 차지합니다.

// s is a StringBuilder
s.append("Hello, World!");

// S is a String
S+="Hello, World!";

문자열을 뒤집어 바로 인쇄해야하는 경우을 사용하십시오 StringBuffer.

System.out.print(new StringBuilder("Hello, World!").reverse());
System.out.print(new StringBuffer("Hello, World!").reverse()); // Note that you can omit toString() when printing a non-String object

문자열을 뒤집은 다음 인쇄하지 않고 다른 작업을 수행해야하는 경우 for각 루프를 사용하십시오 .

String b=new StringBuffer("Hello, World!").reverse().toString();
String B="";for(String c:"Hello, World!".split(""))B=c+B;

Java 10 사용 var

특정 유형의 단일 변수를 정의하는 경우을 사용하십시오 var.

예

var i=0;                        // int
var l=0L;                       // long
var s="";                       // String
var a=new int[]{1,2,3};         // int[]
var i=java.math.BigInteger.ONE; // BigInteger
var m=new java.util.HashMap();  // HashMap
var i=3+"abc".length()          // int
var a="a b c".split(" ");       // String[]
for(var a:"a b c".split(" "))   // String

다음 예에서는 사용할 수 없습니다

var 많은 예제에서 사용할 수 없습니다

var i=1,j=2;           // only one variable is accepted at a time
var a={1,2,3};         // arrays must be explicitly declared
var f=a->a+" ";        // can't know what type a is.
var f=String::replace; // method references aren't properly implied (weirdly, though)

대부분의 경우 프로그램은 단일 스레드입니다. 즉, 하나의 스레드 만 실행됩니다. return즉시 종료해야 할 때 주요 방법을 사용하여이 사실을 악용 할 수 있습니다 .

static void main(String[]a){if(condition)return;}

프로그램을 "적절하게"종료하는 것과 비교하십시오.

static void main(String[]a){if(condition)System.exit(0);}

또는 가리키는 null:

static void main(String[]a){if(condition)throw null;}

또는 0으로 나누기 :

static void main(String[]a){if(condition)int A=1/0;}

때로는 단일 for-loop 문을 대체 할 수 있습니다. 다음 코드를 고려하십시오.

int m(int x){int i=1;for(;x%++i==0;);return i;}

이것은 이 질문에 대한 해결책 인 간단한 for-loop입니다 .

iStackOverflow 오류를 일으킬만큼 크지 않다는 것을 알고 있으므로 for 루프를 재귀로 대체 할 수 있습니다.

int m(int x,int i){return x%++i>0?i:m(x,i);}

return 문에서 삼항 연산자를 사용하여 재귀를 발생시켜 루프를 시뮬레이션 할 수 있습니다.

이 축소는 다소 구체적이지만, 이것이 더 유용한 상황을 더 상상할 수 있습니다.

사용 ...매개 변수로 (varags)

경우에 따라 느슨한 변수 대신 Java 변수를 매개 변수로 사용하는 것이 더 짧은 경우도 있습니다.
예를 들면 다음과 같습니다.

// Example input/output: 5, 4, 3 -> 60000
int calculateVolumeInLiters(int width, int height, int depth){
  return width * height * depth * 1000;
}

이것으로 대부분 골프를 칠 것입니다 :

int c(int w,int h,int d){return w*h*d*1000;} // 44 bytes

그러나 이것에 추가 바이트를 넣을 수 있습니다.

int c(int...a){return a[0]*a[1]*a[2]*1000;}  // 43 bytes

세 개의 정수는 모두 메소드 자체에서 한 번만 액세스됩니다. 이후int 아주 짧은 당신이 방법 내에서 한 번만 각을 사용하고, 세 개 매개 변수로 더있는 경우에만 유용합니다.

더 긴 매개 변수를 사용하면 일반적으로 더 유용합니다. 예를 들어, 이것은 이 도전에 대한 나의 원래의 대답이었습니다 (입력 문자열에서 입력 문자의 발생률을 계산하십시오).

// Example input/output: tttggloyoi, t -> 3

int c(String a,char b){return a.replaceAll("[^"+b+"]","").length();} // 68 bytes

그리고 나는 이것을 골프화하는 것이 좋습니다.

int c(String a,char b){return a.split(b+"").length-1;}               // 54 bytes

그러나 나는 이것을 사용하여 이것을 골프로 끝냈습니다 ...:

int c(String...a){return a[0].split(a[1]).length-1;}                 // 52 bytes

참고 : 질문 / 도전이 유연한 입력을 요구하는 경우 물론 ...단축 할 수 있습니다 []. 질문 / 도전이 구체적으로 요구하는 경우, 예를 들어 3 개의 String입력을 요청하고 String3 개의 값을 포함 하는 배열을 허용하지 않는 경우 String...대신 대신 사용할 수 있습니다 String a,String b,String c.