Existe-t-il des raccourcis utiles utilisables en Java?

Comme indiqué ci-dessous, importajoute déjà au moins 17 caractères à un programme.

import java.io.*;

Je comprends que la solution simple consisterait à utiliser un autre langage, mais raccourcir les programmes Java semble être un réel défi.

Les astuces doivent être spécifiques à Java: s’ils s’appliquent à la plupart des langages de type C, ils appartiennent à la liste plus générale d’astuces .

• Utilisez le java le plus récent possible. Java 8 vous permet d' utiliser des expressions lambda, donc l' utiliser si vous avez besoin , même comme des objets fonctionnels.

• Définissez des fonctions abrégées pour les choses que vous utilisez beaucoup. Par exemple, vous avez cent appels à exampleClassInstance.doSomething(someParameter), définir une nouvelle fonction void d(ParameterType p){exampleClassInstance.doSomething(p)}et l'utiliser pour vous épargner des caractères.

• Si vous utilisez plusieurs fois un nom de classe long particulier, comme

  MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory

  à la place, définissez une nouvelle classe:

  class X extends MyEventHandlerProxyQueueExecutorServiceCollectionAccessManagerFactory{}

  Si vous utilisez uniquement une méthode particulière de cette classe (mais que vous avez toujours besoin de l'instancier), vous pouvez définir une version abrégée à l'intérieur de la nouvelle classe en même temps.

• Utilisez les paramètres de type de fonction pour raccourcir les choses, si possible, comme ceci:

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

• Utilisez for(;;)au lieu de while(true).

• N'utilisez pas de modificateurs d'accès, sauf en cas d'absolue nécessité.

• Ne pas utiliser finalpour rien.

• Ne mettez jamais un bloc après une forboucle (mais une boucle foreach for(x:y)est différente). Des déclarations supplémentaires doivent être placées dans la fordéclaration elle-même, comme for(int i=0;i<m;a(i),b(++i))c(i);.

• Utilisez l'affectation en ligne, l'incrémentation, l'instanciation. Utilisez des classes en ligne anonymes, le cas échéant. Utilisez lambdas à la place si possible. Appels de fonction de nid. Certaines fonctions ont la garantie de retourner leur objet parent, celles-ci sont même censées être chaînées.

• Votre mainméthode throws Exceptionne les attrape pas.

• Errorest plus court que Exception. Si pour une raison quelconque vous avez vraiment besoin de throwmessages en haut de la pile, utilisez un Error, même s’il s’agit d’une situation parfaitement normale.

• Si une condition nécessite une résiliation immédiate, utilisez int a=1/0;plutôt que throw null;ou System.exit(0);. Au moment de l'exécution, cela jette un fichier ArithmeticException. Si vous avez déjà une variable numérique dans votre code, utilisez-la à la place. (Si vous avez déjà import static java.lang.System.*;, aller avec exit(0);.)

• Au lieu d'implémenter des interfaces, par exemple List<E>, étendez une classe enfant immédiate (ou pas si immédiate, le cas échéant), comme AbstractList<E>, qui fournit des implémentations par défaut de la plupart des méthodes et ne requiert que l'implémentation quelques pièces clés.

• Écrivez d'abord votre code dans le code de la main, avec les nouvelles lignes, l'indentation et les noms de variables complets. Une fois que vous avez le code de travail, vous pouvez alors raccourcir les noms, déplacer les déclarations et ajouter des méthodes de raccourci. En écrivant longtemps pour commencer, vous vous donnez plus de possibilités de simplifier le programme dans son ensemble.

• Comparez les optimisations alternatives à un élément de code, car la stratégie la plus optimale peut changer de façon spectaculaire en modifiant très peu le code. Par exemple:

  • Si vous avez seulement jusqu'à deux appels Arrays.sort(a), la façon la plus efficace est de l' appeler avec son nom complet, java.util.Arrays.sort(a).
  • Avec trois appels ou plus, il est plus efficace d'ajouter une méthode de raccourci void s(int[]a){java.util.Arrays.sort(a);}. Cela devrait toujours utiliser le nom qualifié complet dans ce cas. (Si vous avez besoin de plus d'une surcharge, vous le faites probablement mal.)
  • Toutefois, si votre code doit également copier un tableau à un moment donné (généralement avec une courte forboucle de golf, en l'absence d'une méthode de bibliothèque facilement accessible), vous pouvez en profiter Arrays.copyOfpour effectuer la tâche. Lorsque plusieurs méthodes sont utilisées et qu'il y a 3 appels ou plus, import static java.util.Arrays.*;la méthode la plus efficace consiste à faire référence à ces méthodes. Par la suite, si vous sortutilisez plus de 8 appels distincts, utilisez une méthode de raccourci, et seulement à 5 appels ou plus, un raccourci est garanti copyOf.

  Le seul moyen réel d'effectuer une telle analyse sur le code consiste à effectuer des modifications éventuelles sur des copies du code, puis à comparer les résultats.

• Évitez d'utiliser la someTypeValue.toString();méthode, ajoutez simplement someTypeValue+"".

• Si vous avez besoin de Windows, n'utilisez pas Swing, utilisez AWT (sauf si vous avez vraiment besoin de quelque chose de Swing). Comparez import javax.swing.*;et import java.awt.*;. De plus, les composants Swing ont un Jpréfixé à leur nom ( JFrame, JLabel, etc.), mais les composants dans AWT ne le font pas ( Frame, Label, etc.)

Utilisez interfaceau lieu de class.

En Java 8, des méthodes statiques ont été ajoutées aux interfaces. Dans les interfaces, toutes les méthodes sont publiques par défaut. par conséquent

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

peut maintenant être raccourci à

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

ce qui est évidemment plus court.

Par exemple, j'ai utilisé cette fonctionnalité dans Hello, World! défi.

Avec varargs, vous pouvez " convertir " un paramètre en un tableau du même type:

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

au lieu de

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

Avec une importation statique :

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

vous pouvez économiser un peu plus tard, mais vous avez besoin de plusieurs invocations pour obtenir un gain:

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

L'argument à mainne doit pas nécessairement être appelé args, et vous pouvez couper certains espaces:

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

fera très bien.

Si vous devez utiliser les expressions booléennes trueou false, remplacez-les par 1>0et 1<0respectivement.

Par exemple:

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

Cet exemple de recherche linéaire peut être réduit à

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

Si vous utilisez beaucoup une méthode, affectez sa classe résidente à une variable. Par exemple, assignez System.outà une variable:

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

Aussi pour Integer.parseInt():

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

Cela déclenchera presque sûrement un avertissement concernant "l'accès à la méthode statique à partir d'une variable"

Plutôt que d’utiliser la import static java.lang.System.*technique pour économiser surprintln() instructions, j'ai constaté que la définition de la méthode suivante est beaucoup plus efficace pour enregistrer des caractères:

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

En effet, il peut être invoqué p(myString)plutôt que de out.println(myString)bénéficier d’un gain de caractère beaucoup plus rapide et spectaculaire.

Cela peut sembler évident, mais il existe des options plus courtes pour certaines Mathfonctions:

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

Si vous avez besoin de Integer.MAX_VALUE(2147483647), utilisez -1>>>1. Integer.MIN_VALUE(-2147483648) est mieux écrit 1<<31.

Si vous devez extraire un nombre d'un argument (ou de toute autre chaîne), vous verrez normalement quelque chose comme:

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

Plusieurs fois, vous n’avez pas besoin d’ un Integer. Beaucoup de défis n'utilisent pas de grands nombres. Étant donné Shortque Byteles deux seront décompressés en un int, utilisez le plus approprié valueOf()et enregistrez quelques octets.

Gardez votre variable réelle comme un int, cependant, car elle est plus courte que les deux byteet short:

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

Si vous devez le faire pour plusieurs numéros, vous pouvez combiner cette méthode :

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

Ne pas utiliser public class. La méthode principale doit être publique, mais pas sa classe. Ce code fonctionne:

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

Vous pouvez courir java Smême si ce class Sn'est pas une classe publique. ( Mise à jour: j'utilisais Java 7 lorsque j'ai écrit cette astuce. En Java 8, votre méthode principale doit être dans une interface . En Java 5 ou 6, votre méthode principale doit être en enum .)

Beaucoup de programmeurs Java ne le savent pas! Environ la moitié des réponses à une question sur le dépassement de pile concernant une classe principale dans une classe non publique prétendent à tort que la méthode principale doit être une classe publique. Maintenant tu sais mieux. Supprimez le publicdans public classet enregistrez 7 caractères.

Quelques petits conseils de code-golf

Ces astuces étaient un peu trop petites pour une réponse séparée, je vais donc utiliser cette réponse pour de très petites astuces de golf-code que j'ai trouvées ou proposées, et qui ne sont pas encore mentionnées dans les autres astuces:

Supprimer le dernier caractère d'une chaîne:

// I used to do something like this:
s.substring(0,s.length()-1)     // 27 bytes

// But this is shorter:
s.replaceAll(".$","")           // 21 bytes

Dans certains cas, vous savez à l’avance le dernier caractère et vous savez également que ce caractère n’apparaît qu’une fois dans la chaîne. Dans ce cas, vous pouvez utiliser à la .splitplace:

// As example: "100%" to "100"
s.split("%")[0]                 // 15 bytes

Raccourcis d'encodage:

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

Tous les encodages ont un nom canonique utilisé dans l' java.nioAPI, ainsi qu'un nom canonique utilisé dans les API java.ioet java.lang. Voici une liste complète de tous les encodages pris en charge en Java. Donc, utilisez toujours le plus court des deux; la seconde est généralement plus courte (comme UTF-8vs utf8, Windows-1252vs Cp1252, etc.), mais pas toujours ( UTF-16BEvs UnicodeBigUnmarked).

Booléen aléatoire:

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

Primes:

Il existe différentes façons de rechercher des nombres premiers ou d'obtenir tous les nombres premiers, mais la réponse de @ SaraJ est la plus courte. Voici un copier-coller comme référence:

// 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*/;}}

REMARQUE: En règle générale, vous pouvez le fusionner avec d'autres boucles existantes en fonction de la manière dont vous souhaitez l'utiliser. Vous n'avez donc pas besoin d'une méthode distincte. Cela a permis d'économiser beaucoup d'octets dans cette réponse, par exemple.

Troncature d'entier au lieu de Math.floor / Math.ceil:

Si vous utilisez des doubles / floats positifs et que vous souhaitez floorles utiliser, n'utilisez pas, Math.floormais utilisez (int)plutôt -cast (car Java tronque les entiers):

double d = 54.99;

int n=(int)Math.floor(d);     // 25 bytes

int m=(int)d;                 // 13 bytes

// Outputs 54 for both

La même astuce peut être appliquée aux doublons / flotteurs négatifs que vous souhaitez utiliser à la ceilplace:

double d = -54.99;

int n=(int)Math.ceil(d);     // 24 bytes

int m=(int)d;                // 13 bytes

// Outputs -54 for both

Utilisez &1au lieu de %2pour vous débarrasser des parenthèses:

Étant donné que la priorité de l' opérateur& est inférieure à celle des opérateurs arithmétiques par défaut tels que */+-et %, vous pouvez supprimer les parenthèses dans certains cas.

// So instead of this:
(i+j)%2     // 7 bytes

// Use this:
i+j&1       // 5 bytes

Notez que cela n'aide pas vraiment dans les contrôles booléens, car alors vous auriez toujours besoin de parenthèses, elles sont juste déplacées un peu:

(i+j)%2<1    // 9 bytes
(i+j&1)<1    // 9 bytes

BigIntegers et la création de variables pour les appels de méthodes statiques:

Lorsque vous utilisez BigIntegers, créez-le une seule fois, que vous pourrez ensuite réutiliser. Comme vous le savez peut-être, BigInteger contient des champs statiques pour ZERO, ONEet TEN. Ainsi, lorsque vous utilisez uniquement ces trois éléments, vous n’avez pas besoin d’un, importmais vous pouvez les utiliser java.Math.BigIntegerdirectement.

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

NOTE: Vous devez utiliser =nullainsi test initialisé pour pouvoir utiliser t..

Parfois, vous pouvez ajouter plusieurs BigIntegers pour en créer un autre afin de sauvegarder des octets. Alors disons que vous voulez avoir les BigIntegers 1,10,12pour une raison quelconque:

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

Comme correctement souligné dans les commentaires, l'astuce avec BigInteger t=null;ses appels de méthode statique peut également être utilisée avec d'autres classes.
Par exemple, cette réponse de 2011 peut être lue:

// 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() au lieu de toCharArray()

Lorsque vous souhaitez effectuer une boucle sur les caractères d'une chaîne, procédez comme suit:

for(char c:s.toCharArray())    // 27 bytes
// or this:
for(String c:s.split(""))      // 25 bytes

Faire une boucle sur les caractères peut être utile pour les imprimer, les ajouter à une chaîne ou quelque chose de similaire.

Toutefois, si vous utilisez uniquement les caractères pour certains calculs de nombre unicode, vous pouvez remplacer le charavec int, ET vous pouvez le remplacer toCharArray()par getBytes():

for(int c:s.getBytes())        // 23 bytes

Ou même plus court en Java 8+:

s.chars().forEach(c->...)      // 22 bytes

En Java 10+, le bouclage sur le caractère à imprimer peut maintenant aussi être effectué sur 22 octets:

for(var c:s.split(""))         // 22 bytes

Article aléatoire de a 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

Vérifier si une chaîne contient des espaces de début / fin

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

Pourquoi cela fonctionne-t-il, alors que !=sur Strings, il faut vérifier la référence au lieu de la valeur en Java? Car String#trimretournera " Une copie de cette chaîne avec les espaces blancs de début et de fin supprimés, ou cette chaîne si elle n'a pas d'espace blanc de début ou de fin . " Je l'ai utilisé, après que quelqu'un me l'ait suggéré, dans ma réponse .

Palindrome:

Pour vérifier si une chaîne est un palindrome (en gardant à l'esprit les longueurs paires et impaires des chaînes), il s'agit de la plus courte ( .containsfonctionne ici car nous savons que la chaîne elle-même et sa forme inversée sont de même longueur):

String s=...;
s.contains(new StringBuffer(s).reverse())    // 41 bytes

.contains(...)au lieu de .equals(...+"")grâce au commentaire de @assylias ici .

Soit 0, ou les deux sont 0?

Je pense que la plupart connaissent déjà celui-ci: si vous voulez vérifier si l'un aou l' autre best égal à zéro, multipliez-le pour sauvegarder les octets:

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

Et si vous voulez vérifier si les deux aet bsont égaux à zéro, vous pouvez utiliser un opérateur OR, ou les ajouter ensemble si elles sont toujours positives:

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)

Pair = 1, impair = -1; ou vice versa

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

La raison pour laquelle j'ai ajouté ceci était après avoir vu k+(k%2<1?1:-1)dans cette réponse :

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

nTemps de boucle dans le programme complet

Si nous avons un défi pour lequel un programme complet est obligatoire et que nous devons boucler un nombre de fois spécifique, nous pouvons procéder comme suit:

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

Il en va de même lorsque nous devons prendre cette plage en entrée:

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

Merci à @JackAmmo pour ce commentaire .

try-finally au lieu de try-catch (Exception e) lors du retour et quand l'utiliser

Si vous ne pouvez pas utiliser un throws Exceptionmais devez le faire catchet y faire quelque chose avant de revenir, vous pouvez utiliser à la finallyplace:

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

En ce qui concerne un exemple d'utilisation d'un try-catch, je peux me référer à cette réponse (le crédit pour le golf indirect va à @KamilDrakari ). Dans ce défi, nous devons boucler en diagonale sur une matrice NxM, nous devons donc déterminer si le nombre de colonnes ou le nombre de lignes est le plus bas que notre maximum dans la boucle for (ce qui est assez coûteux en termes d'octets:) i<Math.min(a.length,a[0].length). Donc, attraper simplement l' ArrayIndexOutOfBoundsExceptionutilisation catch-finallyest plus court que cette vérification, et sauve ainsi des octets:

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

NOTE: Cela a seulement fonctionné à cause de return r;l'enfin. On m'a suggéré de modifier la première cellule, comme l'a fait @KamilDrakari dans sa réponse en C # pour économiser des octets. Cependant, en Java, cela signifie que je devrai le modifier en m->{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch(Exception e){}}(73 octets), ce qui augmenterait le nombre d'octets au lieu de diminuer si j'avais pu l'utiliser finally.

Math.pow (2, n)

Lorsque vous voulez une puissance de 2, une approche un peu sage est beaucoup plus courte:

(int)Math.pow(2,n)    // 16 bytes
(1<<n)                // 6 bytes

Combinaison de contrôles binaires et logiques au lieu d'utiliser des parenthèses

Je pense qu'il est bien connu maintenant que &et |peut être utilisé à la place &&et ||en Java (Boolean) Les contrôles logiques. Dans certains cas, vous souhaiterez quand même utiliser &&au lieu de &pour éviter les erreurs, comme index >= 0 && array[index].doSomething. Si le &&serait changé à &ici, il évaluera toujours la partie où il utilise l'index dans le tableau, provoquant une ArrayIndexOutOfBoundsException, d'où l'utilisation de &&dans ce cas à la place de &.

Jusqu'ici, les bases de &&/ ||vs &/ |en Java.

Lorsque vous voulez vérifier (A or B) and C, le plus court peut sembler utiliser les opérateurs binaires comme celui-ci:

(A|B)&C    // 7 bytes

Toutefois, comme les opérateurs au niveau des bits ont priorité sur les contrôles logiques, vous pouvez combiner les deux pour enregistrer un octet ici:

A|B&&C     // 6 bytes

Utiliser n+=...-nau lieu de(long)...

Lorsque vous avez un long comme dans et sortie dans un lambda, par exemple lors de l'utilisation Math.pow, vous pouvez enregistrer un octet en utilisant à la n+=...-nplace de (long)....
Par exemple:

n->(long)Math.pow(10,n)    // 23 bytes
n->n+=Math.pow(10,n)-n     // 22 bytes

Cela a sauvé un octet dans cette réponse à moi , et même deux octets en combinant -n-1à +~ndans cette réponse à moi .

Pour jouer au golf qui ne nécessite pas d’entrée, vous pouvez utiliser des blocs statiques et le lancer sans aucune méthode principale, il suffit de le compiler avec Java 6.

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

Nous connaissons tous le bitwise xor ( ^), mais c'est aussi un xor logique.

Alors (a||b)&&!(a&&b)devient tout simplement a^b.

Nous pouvons maintenant utiliser xor.

En outre , les opérateurs |et & travaillent également , rappelez-vous simplement que la priorité des opérateurs change.

Vous n'êtes pas obligé d'utiliser Character.toLowerCase(char c). Utilisez plutôt (c|32). Au lieu d' Character.toUpperCase(char c)utiliser (c&~32). Cela ne fonctionne qu'avec les lettres ASCII.

Convertir une chaîne en nombre

Il existe plusieurs façons de convertir une chaîne en valeur numérique:

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

nouvel ABC :

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

Ainsi, pour le code-golf, il est préférable d'utiliser le constructeur lors de la conversion d'une chaîne en valeur numérique.

La même chose s'applique à Double; Float; et Byte.

Cela ne s'applique pas toujours lorsque vous pouvez réutiliser une primitive déjà présente en tant qu'objet.
Par exemple, supposons que nous avons le code suivant:

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

Vous pouvez utiliser .decodele constructeur plus court en réutilisant le paramètre en tant qu'objet:

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
}

Ne pas utiliser Random!

En général, si vous avez besoin de nombres aléatoires, Randomc'est une façon horrible de s'y prendre *. Mieux vaut utiliser à la Math.random()place. Pour l'utiliser Random, vous devez faire ceci (disons qu'il nous faut un int):

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

Comparez cela à:

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

et:

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

La première méthode prend des 41+15ncaractères ( nc'est le nombre d'appels). La seconde est des 25npersonnages, et la troisième est43+7n .

Donc, si vous n'en avez besoin qu'une ou deux fois, utilisez la Math.random()méthode inline . Pour trois appels ou plus, vous enregistrez en utilisant une fonction. Soit on enregistre des caractères sur la première utilisation plus Random.

Si vous utilisez déjà Math.random()pour double, rappelez-vous qu’au bout de quatre utilisations, il reste des économies à réaliser:

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

Pour 33 caractères, vous en économiserez 10 à chaque appel de r()

Mise à jour

Si vous avez besoin d'un entier et que vous souhaitez économiser sur le casting, ne le lancez pas! Java se lance automatiquement si vous effectuez une opération au lieu d'une affectation. Comparer:

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

^{* Sauf si vous devez semer le PRNG pour obtenir des résultats prévisibles. Ensuite, je ne vois pas beaucoup de chemin autour de ça.}

Je ne sais pas si vous considéreriez ce Java «pur», mais Processing vous permet de créer des programmes avec une configuration initiale réduite (terminée automatiquement).

Pour la sortie de la console, vous pouvez avoir quelque chose d'aussi simple que:

println("hi"); //done

pour la sortie graphique, un peu plus:

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
}

Raccourcissement de retour

Vous pouvez raccourcir les instructions de retour de chaînes par un octet avec:

return "something";

à

return"something";

Et, si vous commencez votre déclaration de retour par une parenthèse, vous pouvez faire la même chose avec elles:

return (1+taxRate)*value;

à

return(1+taxRate)*value;

Je suppose que les citations sont considérées comme des parenthèses? En fait, j’ai pris cela au sérieux grâce à AppleScript et j’ai pensé que cela valait la peine d’être mentionné.

N'ayez pas peur d'utiliser la notation scientifique

Si vous avez affaire à des doubles ou à des flottants, vous pouvez utiliser la notation scientifique pour les nombres. Donc, au lieu d'écrire, double a=1000vous pouvez le changer double a=1e3pour sauvegarder 1 octet.

Essayez d'utiliser int au lieu deboolean

Dans certains cas, j'ai constaté qu'il est plus court de renvoyer une valeur entière à partir d'une méthode qui normalement renverrait un booléen, de la même manière que ce qui pourrait être fait dans les programmes C.

Dès le départ, la taille intest 4 octets plus courte que boolean. Chaque fois que vous écrivez à la return 0place de return 1<0, vous enregistrez 2 octets supplémentaires et la même chose pour return 1 over return 1>0.

Le piège est que chaque fois que vous voulez utiliser la valeur de retour directement comme un booléen, cela coûte 2 octets ( if(p(n))v. if(p(n)>0)). Ceci peut être compensé par l'utilisation de l'arithmétique booléenne. Étant donné un scénario artificiel où vous voulez écrire

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

vous pouvez plutôt écrire

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

afin d'économiser 2 octets.

Si vous utilisez enum au lieu de classe , vous enregistrez un caractère.

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

    }
}

Mais vous devez introduire au moins une instance enum (F, G, H dans cet exemple) qui doivent être rentables.

Quand vous avez une méthode qui devrait retourner un booleanou Boolean, c'est-à-dire:

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

Vous pouvez changer le type boolean/ Booleanreturn Objectpour enregistrer 1 octet:

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

De plus, comme vous l'avez peut-être remarqué, vous pouvez utiliser une <1vérification au lieu de ==0sauvegarder un octet. Bien que ce soit plus un conseil de code-golf général au lieu de spécifique à Java.
Ceci est principalement utilisé lorsque le nombre entier ne peut pas être négatif, comme pour vérifier la longueur:

a.length<1

au lieu de

a.length==0

Comment dessiner en Java ...

Voici la plaque de chaudière de peinture GUI la plus courte possible:

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

Golfé pour 111 octets:

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

Éviter StringBuilder s

Ajouter des éléments à a Stringprend beaucoup moins d'octets.

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

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

Si vous devez inverser une chaîne et l’imprimer immédiatement, utilisez a 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

Si vous devez inverser une chaîne et faire autre chose que de l’imprimer, utilisez une forboucle chaque.

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

Utiliser Java 10 var

Si vous définissez une seule variable d'un type spécifique, utilisez var.

Exemples

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

Non utilisable dans les exemples suivants

var ne peut pas être utilisé dans de nombreux exemples

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)

Dans la plupart des cas, votre programme sera mono-thread, c'est-à-dire qu'un seul thread sera en cours d'exécution. Vous pouvez exploiter ce fait en returnutilisant la méthode principale lorsque vous devez quitter instantanément.

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

Comparez-le à "correctement" terminer le programme:

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

Ou pointant vers null:

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

Ou en divisant par 0:

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

Parfois, une seule instruction for-loop peut être remplacée. Considérons le code suivant:

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

Ceci est une simple boucle for qui est une solution à cette question .

Puisque nous savons que icela ne sera pas assez important pour causer des erreurs StackOverflow, nous pouvons remplacer la boucle for par une récursivité:

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

Nous pouvons simuler une boucle en utilisant un opérateur ternaire dans l'instruction return pour provoquer la récursivité.

Cette réduction est assez spécifique, mais je peux imaginer plus de situations où cela serait utile.

En utilisant ... (varags) comme paramètre

Dans certains cas, il est plus court d’utiliser un varargs Java en tant que paramètre plutôt que des paramètres non structurés.
Par exemple:

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

Serait le plus joué au golf à ceci:

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

Mais peut être joué un octet supplémentaire à ceci:

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

Notez que les trois entiers ne sont accessibles qu'une seule fois dans la méthode elle-même. Comme il intest assez court, il n’est utile que de les utiliser une seule fois dans la méthode et d’en avoir trois ou plus comme paramètre.

Avec des paramètres plus longs, cela est généralement plus utile. Par exemple, c’était ma réponse initiale à ce défi (calculer les occurrences du caractère saisi dans la chaîne de saisie):

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

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

Et on m'a recommandé de jouer au golf à ceci:

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

Mais j'ai fini par y mettre le golf en utilisant ...:

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

NOTE: Si la question / défi demande une entrée flexible, ...on peut []bien sûr le raccourcir . Si la question / défi demande spécifiquement, disons, trois Stringentrées et interdit un Stringtableau contenant trois valeurs, vous pouvez utiliser à la String...place de String a,String b,String c.