Welcome to Bukkit France

Inscrivez-vous maintenant pour profiter d'un accès total à tout le contenu offert par la meilleur communauté Bukkit française ! Une fois inscrit et connecté, vous pourrez contribuez à la communauté en postant vos propres sujets et questions ou en répondant à ceux existants. Vous pourrez aussi customiser votre profil, recevoir des points de réputations, communiquer avec les autres membres via le chat, et plus encore! 

TheElectronWill

Membres
  • Compteur de contenus

    806
  • Inscription

  • Dernière visite

Réputation sur la communauté

935 Excellent

À propos de TheElectronWill

  • Rang
    Javaikidoka
  • Date de naissance 02/05/1999

Informations de profil

  • Bukkitorg http://dev.bukkit.org/profiles/TheElectronWill/
  • Centres d'intérêt Informatique, Badminton, Aikido, Piano.
  • Sexe Homme

Me contacter

  • GitHub TheElectronWill
  • Minecraft TheElectronWiill
  • Mail [email protected]il.com
  • Site Web mcphoton.fr
  • Twitter TheElectronWill

Visiteurs récents du profil

3 077 visualisations du profil
  1. [LIB] Night-Config : les configurations en Java

    Je veux bien ajouter xml (et ça serait pas très compliqué) mais faut m'expliquer l'intérêt de la chose pour les fichiers de configuration :   Entre ça: property = value   Et du xml : <property>value</property>   ... ben je vois pas ce qu'apporte le XML à part que c'est plus long et plus pénible ?   Pour sérialiser des objets j'avoue que ça peut être plus pratique car on peut ajouter plus d'infos (encore qu'on pourrait faire la même chose avec des strings dans autre format - mais ça serait moins propre). Mais ça serait peut-être mieux de faire une lib de serialization XML si ça ne sert qu'à ça.
  2. JAVA Mot clef incompréhensible

    C'est à cause de ma prof de prog de cette année. Elle dit absolument tout en français (mais vraiment tout !) alors ça déteint sur les élèves. Au moins j'ai pas fait de "francisisme". C'est le vocabulaire français "officiel"
  3. JAVA Mot clef incompréhensible

    Comme ça a déjà été dit, Serializable est une interface -> regarde le tutoriel d'oracle sur la serialization   transient permet d'exclure un attribut de la serialization. En fait c'est très utile (coucou @SkyBeast ^_^): imagine tu fais tout un tas de calcul en fonction de données et des paramètres entrés par l'utilisateur. Et bien tu veux stocker les données (qui sont toujours les mêmes) mais pas le résultat des calculs ! Et encore moins un éventuel cache. Une solution est donc de déclarer tes attributs résultat et cache comme étant transient.   native sert à indiquer qu'une méthode est implémentée non pas en Java mais avec du code natif (comme du C) via JNI Par exemple System.arraycopy est une méthode native.   volatile est utilisé en programmation "concurrente" ou "multi-thread", donc quand on fait potentiellement plusieurs choses en même temps sur des coeurs (de CPU) différents. Je met potentiellement parce que, même si un code est prévu pour ça, in fine c'est l'OS qui décide de ce qui tourne réellement sur les coeurs. De plus sur une machine avec un seul coeur (et sans hyper-threading, pour faire simple) ben le programme ne pourra pas faire plusieurs choses simultanément   Pour expliquer ce qu'est volatile il faut parler des threads et de cache. Un Thread est une unité d'exécution à l'intérieur d'un programme. Un programme peut démarrer plusieurs threads, et ces derniers ont la capacité de s'exécuter en parallèle. C'est ce qui permet de distribuer le travail sur les coeurs du CPU.   Ce qu'il faut comprendre c'est que, quand il y a plusieurs threads qui utilisent la même variable, chaque thread a le droit de "mettre en cache" cette variable. Et du coup on a un problème : si un thread modifie la variable, les autres n'ont aucune garantie de voir cette modification, et ils peuvent donc continuer à utiliser une valeur obsolète de la variable ! Le plus vicieux, c'est que comme on n'a vraiment aucune garantie, la modification peut être vue tout de suite, ou une minute plus tard, ou 2 jours plus tard, ou jamais ! On ne peut pas savoir et ça peut varier d'une exécution à l'autre.   Ce là que volatile fait son entrée : si une variable est volatile, alors les threads sont forcés d'utiliser la valeur la plus à jour, la dernière valeur qui lui a été assignée. Un exemple d'utilisation est pour arrêter un thread de façon non-brutale : public WorkThread extends Thread { private volatile boolean run = true; /** Arrête le thread.*/ public void stopWorking() { run = false; } @Override public void run() { while(run) { //continue le travail } } } Si run n'était pas volatile, alors la méthode stopWorking ne fonctionnerait pas correctement !   ATTENTION volatile ne permet pas de faire de la synchronization comme le mot-clé synchronized ou les verrous ! Il ne permet pas non plus de faire des opérations de calcul atomiques comme AtomicInteger. Notamment, volatile ne permet pas de gérer correctement un compteur incrémenté depuis plusieurs threads.*   * volatile ne permet pas ça à lui tout seul. Mais avec quelques ingénieuses astuces on peut faire des choses qui fonctionnent de façon sûre en multi-threading sans utiliser ni verrous ni blocs synchronized Par exemple AtomicInteger utilise un attribut volatile. Et on peut faire des files (queues) et autres collections en utilisant volatile astucieusement (mais je ne vais pas rentrer pas dans les détails ici ^^)
  4.   Bonjour à tous ! Aujourd'hui je vous présente ma lib de gestion des configurations: Night-Config ! Il en existe déjà beaucoup, mais j'avais envie de quelque chose de plus simple à utiliser, avec les fonctionnalités les plus utiles et de bonnes performances.   Tout n'est pas terminé, ce n'est pour l'instant qu'une version Bêta. À terme, les formats suivants seront supportés : JSON TOML HOCON YAML 1.2   Le projet est disponible sur Github.     Les bases L'interface Config définit les méthodes disponibles pour toutes les configurations, notamment des getters & setters pour les valeurs : get[Value/Int/Boolean/String/...](path) et set[Value/Int/...](path, value) Le chemin des valeurs peut être : une String dans laquelle chaque partie du chemin est séparée par un point. Par exemple "a.b.c" donne cette structure: a { b { c } } une List<String> dont chaque élément est une partie du chemin. Par exemple une liste "a", "b", "c" donne la même structure que précédemment.   Exemple : Config conf = new SimpleConfig(); conf.setString("a.b.c", "abc"); conf.setInt("five", 5); conf.setDouble("pi", Math.PI); conf.setList("list", Arrays.asList("a", "b", "c"); String str = conf.getString("a.b.c"); int five = conf.getInt("five"); double pi = conf.getDouble("pi"); List<String> list = conf.getList("list");//Pas besoin de cast, et il n'y a pas de warning !   Fichiers de configuration Il suffit d'utiliser une instance de FileConfig. Il y en aura une pour chaque type de fichier supporté (JsonConfig, TomlConfig, etc) Voici un exemple avec une configuration JSON : FileConfig conf = new JsonConfig(); File configFile = new File("path/to/config.json"); try { conf.readFrom(configFile);//lecture du fichier dans la config conf.writeTo(configFile);//écriture de la config dans le fichier } catch (IOException ex) { //ERREUR }   Pour personnaliser le résultat JSON (le type d'indentation par exemple), vous pouvez utiliser un FancyJsonWriter Config conf; try (Writer fileWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8))) { CharacterOutput output = new WriterOutput(fileWriter); FancyJsonWriter.Builder builder = new FancyJsonWriter.Builder(); builder.indent(" ");//indentation de 4 espaces au lieu de la tabulation qui est le réglage par défaut //autres réglages FancyJsonWriter writer = builder.build(output); writer.writeJsonObject(conf); }   Et si vous avez peu de réglages à faire (ou si vous aimez les grosses chaînes d'appel de fonctions ) vous pouvez aussi créer le Writer comme ça : FancyJsonWriter writer = new FancyJsonWriter.Builder().indent(" ").build(output);     Vérification et correction automatique des configurations Oui vous avez bien lu : correction automatique des configurations ! Concrètement, tout ce que vous avez à faire est de créer une spécification pour votre config : définir quels chemins doivent exister et quelles valeurs sont correctes. Vous pourrez ensuite, avec un simple appel de méthode, vérifier que votre configuration est correcte et/ou la corriger automatiquement. Pour tout ça on utilise une ConfigSpecification : ConfigSpecification spec = new ConfigSpecification(); spec.defineInt("int", 0, -20, 20);//"int" doit être un int compris entre -20 et 20 (inclus). La valeur par défaut est 0 spec.defineString("string", "default", "possibleValueA", "possibleValueB", "possibleValueC", "default");//"string" doit être une String égale à //"possibleValueA", "possibleValueB", "possibleValueC" ou "default". La valeur par défaut est "default" boolean isValid = spec.check(conf);//true si et seulement si la configuration 'conf' est correcte spec.correct(conf);//corrige la configuration La correction fonctionne ainsi : Toute valeur qui ne devrait pas exister est supprimée Toute valeur qui devrait exister mais qui est incorrecte est remplacée par la valeur par défaut Toute valeur manquante est ajoutée, et la valeur par défaut est utilisée.     Conversion objet/config Night-Config peut convertir une configuration en objet Java et vice-versa, à l'aide des classes du paquet reflection. Et pas besoin d'annoter la classe ni de lui faire implémenter une interface spécifique Un petit exemple avec la classe suivante : public class MyObject { int integer; double decimal; String string; List<String> stringList; Config config; MyObject subObject; }   Conversion config -> MyObject : Config conf = new SimpleConfig(); conf.setDouble("decimal", Math.PI); conf.setString("string", "value"); conf.setList("stringList", list1); conf.setConfig("config", config1); conf.setInt("subObject.integer", -1); conf.setDouble("subObject.decimal", 0.5); conf.setString("subObject.string", "Hey!"); conf.setList("subObject.stringList", list2); conf.setConfig("subObject.config", config2); conf.setConfig("subObject.subObject", null); ConfigToObjectMapper coMapper = new ConfigToObjectMapper(); MyObject objectInstance = coMapper.map(conf, MyObject.class);   Conversion MyObject -> Config : MyObject object = new MyObject(); // [...] définition des variables de l'objet ObjectToConfigMapper ocMapper = new ObjectToConfigMapper(); Config conf = new SimpleConfig(); ocMapper.map(object, conf);  
  5. [YAML] Mise à jour d'un fichier depuis le .jar ?

    Utilise la méthode JavaPlugin.getResource(String) pour ouvrir un InputStream vers ton fichier dans le jar.   Par exemple dans la classe principale du plugin, tu peux faire ça : YamlConfiguration configInJar = YamlConfiguration.loadConfiguration(getResource("myFile.yml"));  
  6. Scala VS Java

    Si si, ça ne change rien au problème: au début, SCISSORS n'existe pas. Donc on ne peut pas faire référence à sa méthode equals.
  7. Scala VS Java

    Parce qu'on ne peut pas faire référence à une variable avant sa déclaration, et ça vaut aussi pour les enums ! Essaie de compiler tu aura une jolie erreur "Illegal forward reference" Cf  http://stackoverflow.com/questions/5678309/illegal-forward-reference-and-enums
  8. Scala VS Java

    Si quelqu'un qui s'y connait en Rust pouvait passer par là (Appel aux @DevRust !), j'aimerais bien voir ça aussi
  9. Scala VS Java

    Il a compacté son map: const std::map<GameObject::Type, GameObject::Type> GameObject::win_against { {Type::paper, Type::rock}, {Type::rock, Type::chisel}, {Type::chisel, Type::paper} }; En tout cas je me basais pas sur quelques lignes de + ou de moins pour contester (amicalement) sa victoire, mais sur la simplicité et la clarté du code. Si je veux je peux tout compacter sur une seule ligne public class Shifoumi{public static void main(String[]args){Handsign h1=Handsign.ROCK,h2=Handsign.PAPER;int comp=h1.compare(h2);if(comp==0)System.out.println("Equality!");else if(comp>0)System.out.println("Player 1 wins!");else System.out.println("Player 2 wins!");}}enum Handsign{ROCK,PAPER,SCISSORS;static{ROCK.winAgainst=SCISSORS;PAPER.winAgainst=ROCK;SCISSORS.winAgainst=PAPER;}private Handsign winAgainst;public int compare(Handsign h){if(h==this)return 0;if(h==winAgainst)return 1;return-1;}}  
  10. Scala VS Java

    @ObimwaKenobiJe pense pas non: Asu 26 lignes, moi 25.
  11. Scala VS Java

    @SkyBeastHum hum...   Ça c'est un code correct (et concis par la même occasion) : public class Shifoumi { public static void main(String[] args) { Handsign h1 = Handsign.ROCK, h2 = Handsign.PAPER; int comp = h1.compare(h2); if (comp == 0) System.out.println("Equality!"); else if (comp > 0) System.out.println("Player 1 wins!"); else System.out.println("Player 2 wins!"); } } enum Handsign { ROCK, PAPER, SCISSORS; static { ROCK.winAgainst = SCISSORS; PAPER.winAgainst = ROCK; SCISSORS.winAgainst = PAPER; } private Handsign winAgainst; public int compare(Handsign h) { if (h == this) return 0; if (h == winAgainst) return 1; return -1; } }   On peut même ajouter des lambdas facilement: enum Handsign { ROCK, PAPER, SCISSORS; static { ROCK.winFunction = SCISSORS::equals; PAPER.winFunction = ROCK::equals; SCISSORS.winFunction = PAPER::equals; } private Predicate winFunction;//import java.util.function.Predicate; public int compare(Handsign h) { if (h == this) return 0; if (winFunction.test(h)) return 1; return -1; } }   @while(true);du coup la victoire incontestable du C++ semble contestée
  12. Méthode saveResource

    Et pourquoi tu ne veux pas utiliser des Configuration directement ? Ça t'éviterai de copier les données dans un Map ^^ Les configs utilisent des HashMap donc les opérations get/set sont en O(1) (temps constant) et sont rapides Ok tu gagnera peut-être un peu en vitesse, mais pas tant que ça. Mesure pour être sûr que ça vaut le coup de te compliquer la vie pour ça   À part ça, ne te préoccupe pas trop de la consommation mémoire d'un HashMap<String, Map<String, String>>. Y a un moment où il faut utiliser la structure qui convient. Les Map sont faits et optimisés pour ça. Je ne vois pas de structure plus adaptée à ton problème. En surtout, je doute que tu aies des milliers de Map avec des milliers valeurs dedans. Donc ça ira très bien   Si tu veux optimiser quelque chose tu peux, au lieu de charger toutes les langues, ne charger que celle choisie par l'utilisateur. (à moins que tu aies besoin d'utiliser toutes les langues en même temps ?) Ça c'est utile et efficace.
  13. Informations temporaire entre un site et un serveur

    Quelques exemples d'utilisation de requêtes HTTP en Java : https://www.mkyong.com/java/how-to-send-http-request-getpost-in-java/
  14. Dimensions - API de génération de monde gratuite et open-source

    En voilà un projet très intéressant Si l'implémentation est bien étoffée il pourra me servir pour Photon. Et si je développe une bonne génération des mondes avant vous je serai heureux de pouvoir vous aider   Très bonne continuation !
  15. Méthode saveResource

    Tu peux créer des configurations supplémentaires (en plus de la config de base). -> regarde ici Pour les stocker en mémoire, un Map<String, FileConfiguration> fera l'affaire   Donc tu parcours ta liste de la config, et pour chaque élément tu a 2 cas: Le fichier yml correspondant existe -> tu charge la config avec YamlConfiguration.loadConfiguration(File) et tu la met dans le Map Le fichier n'existe pas -> tu crée une nouvelle config avec new YamlConfiguration(), tu met des trucs dedans (ou pas, comme tu veux ^^) et tu la sauvegarde pour créer le fichier avec le bon contenu.