Échantillon de bibliothèque d'algorithmes Java

■■■■ Bibliothèque d'algorithmes Java -Artery- Exemple ■■■■

Je vais vous présenter l'utilisation et l'exemple de la bibliothèque d'algorithmes Java Artery que je développe. Cet article est la table des matières. Les échantillons non téléchargés sur Qiita sont inclus dans le téléchargement vectoriel ci-dessous.

C'est une bibliothèque pour créer des algorithmes, de la logique et des structures de données sur la mémoire qui se produisent fréquemment lors de la programmation avec Java. Vous pouvez remplacer un code complexe et long par du code simple et testé.

Les échantillons seront ajoutés un par un. Cependant, il n'explique pas toutes les fonctions.

Artery comprend également une bibliothèque de tests unitaires. Vois ici. Java Unit Test Library-Artery-Sample

La bibliothèque Artery peut être téléchargée à partir de ce qui suit. Vector ⇒ Programmation ⇒ Java Language version202005 --2020 / 06/03 publiée

La bibliothèque Artery peut être utilisée gratuitement, y compris à des fins commerciales.

Aperçu des fonctionnalités

Classe de construction de structure de données liée à la classe standard Java (S00)

Les objectifs de traitement de ces classes sont les suivants. La classe de traitement est entre parenthèses.

Traitement associé à la liste (ArList) (00)

Aperçu

Génération de liste (à partir de (Liste, tableau, Ensemble, chaîne de caractères CSV), chaîne de caractères / nombre répétitifs)

□ Liste de clonage (la correspondance de cette liste elle-même ne peut pas être clonée)

ArList.java


  /**Liste des clones.Correspondance dont la liste elle-même n'est pas clonable. */
   public static <T> List<T> clone(List<T> list)

[S00_00_00]

□ Générer une liste à partir d'un tableau (celui généré par Arrays # asList ne peut pas être modifié) ou Set

ArList.java


   /**Définir l'argument de longueur variable sur Liste.Arrays#Parce qu'il ne peut pas être modifié lorsqu'il est généré avec asList. */
   public static <T> List<T> construct(T... values)

[S00_00_01]

□ Générer une liste à partir d'une chaîne de caractères CSV

Le séparateur peut être spécifié ainsi que la virgule.

ArList.java


   /**Divisez par virgule pour faire une liste. */
   public static List<String> construct(String str) 
   /**Divisez par ensemble pour faire une liste. */
   public static List<String> constructFromCsv(String str,char sep)

[S00_00_02]

□ Générer une liste de valeurs numériques à intervalles réguliers

ArList.java


   /**Générer des nombres de comptage du début à des intervalles d'étape. */
   public static List<Integer> constructSeqList(int start,int count,int step)

[S00_00_03]

□ Générer une liste de nombres aléatoires

ArList.java


   /** start(Comprenant)De la fin(Non inclus)Générer un nombre entre les temps de comptage. */
   public static List<Integer> constructRandomList(int start,int end,int count)

[S00_00_03]

□ Générer une liste de lettres aléatoires de la longueur spécifiée

ArList.java


   /**Générer un nombre de chaînes alphabétiques de longueur.Vous pouvez spécifier uniquement des majuscules, uniquement des minuscules ou un mélange en spécifiant des spécifications.. */
   public static List<String> constructRandomList(int len,ArCaseSpec spec,int count)

[S00_00_04]

□ Générer une liste de valeurs spécifiées

ArList.java


   /**Générer la valeur spécifiée pour le nombre de comptages. */
   public static <T> List<T> construct(T value,int count)

[S00_00_05]

Liste des modifications (interdire les valeurs nulles / dupliquées, supprimer toutes les valeurs spécifiées par la condition, échanger des éléments)

□ Évitez d'insérer des valeurs nulles ou en double dans la liste.

ArList.java


   /**
    *Évitez d'insérer des valeurs nulles ou de dupliquer des données dans la liste<br>
    * @param ignoreNull : ArNull.IGNORER ⇒ Ne pas insérer
    * @param ignoreDup : ArDuplicate.IGNORER ⇒ Ne pas insérer
    * @return Renvoie vrai si inséré.
    */
  public static <T> boolean add(List<T> list,T e,ArNullIgnore arNull,ArDuplicateIgnore arDup)
   /**
    *Évitez d'insérer des valeurs nulles ou de dupliquer des données dans la liste<br>
    * @param ignoreNull : ArNull.IGNORER ⇒ Ne pas insérer
    * @param ignoreDup : ArDuplicate.IGNORER ⇒ Ne pas insérer
    * @return Renvoie vrai si inséré.
    */
  public static <T> boolean add(List<T> list,int index, T e,ArNullIgnore arNull,ArDuplicateIgnore arDup)

[S00_00_06]

□ Supprime toutes les valeurs spécifiées de List. Remarque: List # remove supprime uniquement le premier élément

ArList.java


   /**Supprimer tous les éléments spécifiés de la liste.Remarque, liste#remove($Value)Supprime uniquement le premier élément*/
   public static <$Value> void removeAll(List<$Value> list,$Value value)
   /**Supprimer tous les éléments qui correspondent au validateur de la liste. */
   public static <$Value> void removeAll(List<$Value> list,ArValidator<$Value) validator

[S00_00_07]

□ Trier la liste. Éliminez simplement le besoin de spécifier un comparateur

ArList.java


   /**Trier la liste des comparables*/
   public static void sort(List<Comparable> list,ArSortDir dir)

[S00_00_08]

□ Insérez la valeur int dans la liste dans un état trié

ArList.java


   /**Insérer des valeurs int triées dans la liste*/
   public static void insert(List<Integer> list,int value,ArSortDir dir)

□ Permutez les éléments aux positions spécifiées dans la liste.

ArList.java


   /**Permuter les éléments à des positions spécifiées. */
   public static <T> void swap(List<T> list,int index0,int index1)

Conversion de liste (ordre aléatoire / inverse, conversion de valeur, conversion de type, en (MapOnMap, ListOnMap, ArMatrix, etc.))

□ Randomiser l'ordre des éléments dans la liste

ArList.java


   /**Randomiser l'ordre des éléments dans la liste.La liste d'origine est inchangée.*/
   public static <T> List<T> randomize(List<T> list)

[S00_00_09]

□ Inversez les éléments de List

ArList.java


   /**Inverser l'ordre des éléments dans la liste.La liste d'origine est inchangée.*/
   public static <T> List<T> reverse(List<T> list)

[S00_00_10]

□ Convertissez la valeur List en une autre valeur spécifiée dans Map, laissez la valeur non spécifiée telle quelle

ArList.java


   /**Convertir la valeur de List en une autre valeur spécifiée dans Map.La valeur non spécifiée reste la même*/
   public static <$element> void changeValue(List<$element> list,Map<$element,$element> map)

[S00_00_11]

□ Convertissez la valeur List en une autre valeur spécifiée par ArCreator, laissez la valeur non spécifiée telle quelle

ArList.java


   /**Convertit la valeur de List en une autre valeur spécifiée par ArCreator. */
   public static <T0,T1> void changeValue(List<T0> list,ArCreator<T0,T0> creator) throws Exception

[S00_00_12]

□ Créez une nouvelle liste en convertissant le type d'élément de la liste en un autre type avec ArCreator

ArList.java


   /**Créez une nouvelle liste en convertissant le type d'élément de la liste en un autre type avec ArCreator*/
   public static <T0,T1> List<T1> convert(List<T0> list,ArCreator<T0,T1> creator) throws Exception

[S00_00_13]

□ Convertir la liste en carte, spécifiez la clé par nom de champ

ArList.java


   /**Convertir la collection en carte, spécifier la clé par nom de champ*/
   public static <T0,T1> Map<T1,T0> createMap(Collection<T0> collection,String keyField) throws Exception

[S00_00_14]

□ Convertir la liste en carte, spécifier la clé et la valeur par nom de champ

ArList.java


   /**Convertir la collection en carte, spécifiez la clé et la valeur par nom de champ*/
   public static <T0,T1,T2> Map<T1,T2> createMap(Collection<T0> collection,String keyField,String valueField) throws Exception

[S00_00_15]

□ Convertir la liste en carte, générer la clé avec ArCreator

ArList.java


   /**Convertir la collection en carte, générer la clé avec ArCreator*/
   public static <$Element, $Key> Map<$Key,$element> createMap(Collection<$Element> collection,ArCreator<$Element,$Key> creator) throws Exception

[S00_00_16]

□ Convertir la liste en carte, générer des clés et des valeurs avec ArCreator

ArList.java


   /**Convertissez la collection en carte, générez des clés et des valeurs avec ArCreator*/
   public static <$Element, $Key, $Value> Map<$Key,$Value> createMap(Collection<$Element> collection,ArCreator<$Element,$Key> creator1,ArCreator<$Element,$Value> creator2) throws Exception

[S00_00_17]

□ Convertir la liste en ArMatrix (carte à deux dimensions), spécifiez la clé par nom de champ

ArList.java


   /**Collection ArMatrix(Carte bidimensionnelle)Convertir en, la clé est spécifiée par le nom du champ*/
   public static  <$key0, $key1, $value> ArMatrix<$key0,$key1,$value> createArMatrix(Collection<$value> collection,String key0Field,String key1Field) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InvocationTargetException

[S00_00_18]

□ Convertir la liste en ArMatrix (carte à deux dimensions), générer la clé avec ArCreator

ArList.java


   /**Collection ArMatrix(Carte bidimensionnelle)Convertir en clé générée par ArCreator*/
   public static <T0,T1,T2> ArMatrix<T0,T1,T2> createArMatrix(Collection<T2> collection,ArCreator<T2,T0> key0Creator,ArCreator<T2,T1> key1Creator) throws Exception

[S00_00_19]

□ Convertir la liste en MapOnMap (carte en deux étapes), spécifier la clé primaire et la clé secondaire par nom de champ

ArList.java


   /**Carte de la collection(Carte en deux étapes)La clé primaire et la clé secondaire à convertir sont spécifiées par le nom du champ.*/
   public static <$Key0,$Key1,$Value> Map<$Key0,Map<$Key1,$Value>> createMapOnMap(Collection<$Value> collection,String key0Field,String key1Field) throws Exception

[S00_00_20]

□ Convertir la liste en MapOnMap (carte en deux étapes), générer la clé primaire et la clé secondaire avec ArCreator

ArList.java


   /**Carte de la collection(Carte en deux étapes)La conversion en, la clé primaire et la clé secondaire sont générées par ArCreator*/
   public static <$Key0,$Key1,$Value> Map<$Key0,Map<$Key1,$Value>> createMapOnMap(Collection<$Value> collection,ArCreator<$Value,$Key0> key0Creator,ArCreator<$Value,$Key1> key1Creator) throws Exception

[S00_00_21]

□ Convertir la liste en ListOnMap (List on Map), spécifiez la clé par nom de champ

ArList.java


   /**Collection ListOnMap(Liste sur la carte)Convertir en, la clé est spécifiée par le nom du champ*/
   public static <$Key, $Value> Map<$Key,List<$Value>> createListOnMap(Collection<$Value> collection,String keyField) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, IllegalArgumentException, InvocationTargetException

[S00_00_22]

□ Convertir la liste en ListOnMap (liste sur la carte), générer la clé avec ArCreator

ArList.java


   /**ListOnMap(Liste sur la carte)Convertir en clé générée par ArCreator*/
   public static <$Key,$Value> Map<$Key,List<$Value>> createListOnMap(Collection<$Value> collection,ArCreator<$Value,$Key> keyCreator) throws Exception

□ Convertir la liste en ensemble

ArList.java


   /**Convertir la liste en ensemble*/
   public static <T> Set<T> toSet(List<T> list)

□ Convertir la liste d'entiers en tableau int

ArList.java


   /**Convertir une liste d'entiers en un tableau d'entiers*/
   public static int[] toIntArray(List<Integer> integerList)

Extraction des valeurs de liste (suppression des valeurs en double, spécification d'index, spécification d'intervalle, spécification de condition)

□ Extraire uniquement les éléments en double de la liste et créer une nouvelle liste

ArList.java


   /**Créer une nouvelle liste en extrayant uniquement les éléments en double de la liste*/
   public static <T> List<T> selectDuplicated(List<T> list)

[S00_00_23]

□ Créer une nouvelle liste sans éléments en double de la liste

ArList.java


   /**Créer une nouvelle liste avec des éléments en double dans la liste supprimés*/
   public static <T> List<T> removeDuplicated(List<T> list)

[S00_00_24]

□ Extrait les éléments de l'index spécifié (autres que) de List et crée une nouvelle List

ArList.java


   /**Extrait les éléments de l'index spécifié de la liste et crée une nouvelle liste*/
   public static <T> List<T> select(List<T> list,List<Integer> indexes)
   /**Crée une nouvelle liste en extrayant des éléments autres que l'index spécifié de la liste*/
   public static <T> List<T> selectExcept(List<T> list,List<Integer> indexes)

[S00_00_25]

□ Extrayez les éléments de l'index (autres que) qui correspondent à ArValidator de la liste et créez une nouvelle liste

ArList.java


   /**Extrayez l'élément d'index qui correspond à ArValidator de la liste et créez une nouvelle liste*/
   public static <T> List<T> selectByIndex(List<T> list,ArValidator<Integer> validator)
   /**Créer une nouvelle liste en extrayant les éléments non indexés qui correspondent à ArValidator de la liste*/
   public static <T> List<T> selectByIndexExcept(List<T> list,ArValidator<Integer> validator)

[S00_00_27]

□ Crée une nouvelle liste en extrayant des éléments du début de la liste (à partir de la fin) à des intervalles spécifiés.

ArList.java


   /**Crée une nouvelle liste en récupérant les éléments du début de la liste à des intervalles spécifiés*/
   public static <T> List<T> select(List<T> list,int start,int interval,int count)
   /**Crée une nouvelle liste en récupérant des éléments de la fin de la liste à des intervalles spécifiés*/
   public static <T> List<T> selectReverse(List<T> list,int start,int interval,int count)

[S00_00_26]

□ Extrayez les éléments qui correspondent (ne correspondent pas) à ArValidator of List et créez une nouvelle List

ArList.java


  /**Créer une nouvelle liste en extrayant les éléments qui correspondent à l'ArValidator de la liste*/
  public static <T> List<T> select(List<T> list,ArValidator<T> validator)
  /**Créer une nouvelle liste en extrayant les éléments qui ne correspondent pas à l'ArValidator de la liste*/
  public static <T> List<T> selectExcept(List<T> list,ArValidator<T> validator)

[S00_00_28]

Obtenir l'index de la valeur de liste (spécification de valeur directe, spécification de condition de valeur, nombre continu de spécification de condition de valeur)

□ Renvoie l'index de la valeur spécifiée après l'index spécifié, spécifiez la valeur directement ou spécifiez ArValidator

ArList.java


   /**Renvoie l'index de la valeur spécifiée après l'index spécifié, la valeur est spécifiée directement*/
   public static <T> List<Integer> getIndexes(List<T> list,T element,int start) 
   /**Renvoie l'index de la valeur spécifiée après l'index spécifié, la valeur est spécifiée par ArValidator*/
   public static <T> List<Integer> getIndexes(List<T> list,ArValidator<T> validator,int start)

[S00_00_29]

□ Renvoie l'index de la valeur spécifiée avant l'index spécifié, spécifiez la valeur directement ou spécifiez ArValidator

ArList.java


   /**Renvoie l'index de la valeur spécifiée avant l'index spécifié, la valeur est spécifiée directement*/
   public static <T> List<Integer> getIndexesReverse(List<T> list,T element,int end)
   /**Renvoie l'index de la valeur spécifiée avant l'index spécifié, la valeur est spécifiée par ArValidator*/
   public static <T> List<Integer> getIndexesReverse(List<T> list,ArValidator<T> validator,int end)

□ La valeur spécifiée après les inbooks spécifiés renvoie l'index consécutivement plus que le nombre de fois spécifié, la valeur est spécifiée par ArValidator

ArList.java


  /**Renvoie un index dans lequel la valeur spécifiée depuis les inbooks spécifiés continue le nombre de fois spécifié.*/
  public static <T> List<Integer> sameValueSequence(List<T> list,ArValidator<T> validator,int count,int start)

□ La valeur spécifiée avant les inbooks spécifiés renvoie l'index consécutivement plus que le nombre de fois spécifié, la valeur est spécifiée par ArValidator

ArList.java


   /**Renvoie un index dans lequel la valeur spécifiée avant les inbooks spécifiés continue pendant le nombre de fois spécifié ou plus.*/
  public static <T> List<Integer> sameValueSequenceReverse(List<T> list,ArValidator<T> validator,int count,int end)

Nombre de valeurs de liste et jugement d'existence (valeur en double, valeur nulle, spécification de condition de valeur / spécification d'index / spécification de nombre)

□ Déterminez si la liste est nulle ou vide

ArList.java


   /**Déterminer si Collection est nulle ou vide*/
   public static <T> boolean isNullOrEmpty(Collection<T> list) 
   /**Déterminer si Colleciton est nul ou vide*/
   public static <T> boolean isNotNullOrEmpty(Collection<T> list)

□ Comptez le nombre d'occurrences pour déterminer s'il y a des valeurs en double dans la liste

ArList.java


   /**Déterminer si la liste contient des valeurs en double*/
   public static <T> boolean duplicated(List<T> list)
   /**Compter le nombre d'occurrences des valeurs de liste*/
   public static <T> Map<T,Integer> countValue(List<T> list)

[S00_00_31]

□ Comptez le nombre de valeurs spécifiées dans List, spécifiez directement la valeur ou spécifiez ArValidator

ArList.java


  /**Comptez le nombre de valeurs spécifiées, spécifiez la valeur directement*/
  public static <T> int count(Collection<T> list,T value) 
  /**Compte le nombre de valeurs spécifiées, les valeurs sont spécifiées par ArValidator*/
  public static <T> int count(Collection<T> list,ArValidator<T> validator)

[S00_00_32]

□ Renvoie l'index de la valeur spécifiée après l'index spécifié de List, spécifie directement la valeur ou spécifie ArValidator

ArList.java


   /**Renvoie l'index de la valeur spécifiée après l'index spécifié, la valeur est spécifiée directement*/
   public static <$Value> int contains(List<$Value> list,int index,$Value value) 
   /**Renvoie l'index de la valeur spécifiée après l'index spécifié, la valeur est spécifiée par ArValidator*/
   public static <$Value> int contains(List<$Value> list,int index,ArValidator<$Value> validator)

[S00_00_33]

□ Déterminez s'il n'y a qu'une seule valeur spécifiée par ArValidator dans la liste

ArList.java


   /**Détermine si une seule valeur spécifiée par ArValidator existe*/
   public static <$Element> boolean containsOnlyOne(Collection<$Element> list,ArValidator<$Element> validator)

□ Déterminez s'il y a plus d'une valeur spécifiée par ArValidator dans la liste

ArList.java


   /**Détermine si une ou plusieurs valeurs spécifiées par ArValidator existent*/
   public static <T> boolean contains(Collection<T> collection,ArValidator<T> validator)

□ Juger que la valeur spécifiée par ArValidator n'existe pas dans la liste

ArList.java


   /**Détermine que la valeur spécifiée par ArValidator n'existe pas*/
   public static <$Element> boolean containsNone(Collection<$Element> list,ArValidator<$Element> validator)

□ Déterminez que tous les éléments de la liste ont les valeurs spécifiées par ArValidator

ArList.java


   /**Détermine que tous les éléments ont les valeurs spécifiées par ArValidator*/
   public static <$Element> boolean containsAll(Collection<$Element> list,ArValidator<$Element> validator)

□ Déterminez si tous les éléments de List1 sont inclus dans List0

ArList.java


   /**Déterminez si tous les éléments de List1 sont inclus dans List0*/
   public static <$Value> boolean contains(List<$Value> list0,List<$Value> list1)

Valeurs agrégées des valeurs de liste (valeur minimale, valeur maximale, valeur totale, valeur moyenne, écart type)

□ Calculez la valeur agrégée des valeurs obtenues à partir des éléments de List, et obtenez les valeurs des éléments avec ArCreator.

ArList.java


   /**Calculer la valeur minimale obtenue à partir de l'élément de Collection, obtenir la valeur de l'élément avec ArCreator*/
   public static <T> Number min(Collection<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Trouvez l'indice de la valeur minimale obtenue à partir de l'élément de List, la valeur est obtenue à partir de l'élément avec ArCreator*/
   public static <T> List<Integer> minIndex(List<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Calculer la valeur maximale obtenue à partir de l'élément de Collection, obtenir la valeur de l'élément avec ArCreator*/
   public static <T> Number max(Collection<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Trouvez l'indice de la valeur maximale obtenue à partir de l'élément de List, la valeur est obtenue à partir de l'élément avec ArCreator*/
   public static <T> List<Integer> maxIndex(List<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Calculez la valeur totale des valeurs obtenues à partir des éléments de Collection, les valeurs sont obtenues à partir des éléments avec ArCreator*/
   public static <T> Number sum(Collection<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Calculer la valeur moyenne des valeurs obtenues à partir des éléments de Collection, les valeurs sont obtenues à partir des éléments avec ArCreator*/
   public static <T> Double avg(Collection<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Calculer la valeur de l'écart type de la valeur obtenue à partir de l'élément de Collection, la valeur est obtenue à partir de l'élément avec ArCreator*/
   public static <T> Double standardDeviation(Collection<T> list,ArCreator<T,? extends Number> creator) throws Exception

Valeur de transition de la valeur de liste (valeur moyenne mobile, taux de fluctuation (valeur) (à partir de l'initiale ou du milieu), pourcentage, valeur cumulée (à partir de l'initiale ou du milieu))

□ Calculez la valeur de transition de la valeur obtenue à partir des éléments de List

ArList.java


   /**Calculer la moyenne mobile des valeurs obtenues à partir des éléments de la liste*/
   public static <T> List<Double> movingAvg(List<T> list,ArCreator<T,? extends Number> creator,int span) throws Exception
   /**Calculez la valeur moyenne mobile des valeurs obtenues à partir des éléments de List et écrivez-la dans la List d'origine*/
   public static <T> void movingAvg(List<T> list,ArCreator<T,? extends Number> creator,int span,String updateField) throws Exception
   /**Calculer le taux de variation à partir de la valeur initiale de la valeur obtenue à partir des éléments de List*/
   public static <T> List<Double> fluctuationRatio(List<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Calculer le taux de fluctuation de la valeur obtenue à partir des éléments de la liste à partir de la valeur initiale et l'écrire dans la liste d'origine*/
   public static <T> void fluctuationRatio(List<T> list,ArCreator<T,? extends Number> creator,String updateField) throws Exception 
   /**Calculer la plage de fluctuation de la valeur obtenue à partir des éléments de List à partir de la valeur initiale*/
   public static <T> List<? extends Number> fluctuationWidth(List<T> list,ArCreator<T,? extends Number> creator) throws Exception 
   /**Calculez la plage de fluctuation de la valeur obtenue à partir des éléments de List à partir de la valeur initiale et écrivez-la dans la List d'origine*/
   public static <T> void fluctuationWidth(List<T> list,ArCreator<T,? extends Number> creator,String updateField) throws Exception
   /**Calculer le taux de variation de la plage avant la valeur obtenue à partir des éléments de List*/
   public static <T> List<Double> fluctuationRatio(List<T> list,ArCreator<T,? extends Number> creator,int span) throws Exception
   /**Calcule le taux de fluctuation de la valeur obtenue à partir des éléments de la liste de la plage précédente et l'écrit dans la liste d'origine.*/
   public static <T> void fluctuationRatio(List<T> list,ArCreator<T,? extends Number> creator,int span,String updateField) throws Exception
   /**Calculer la plage de fluctuation de la valeur obtenue à partir des éléments de List de la plage précédente*/
   public static <T> List<? extends Number> fluctuationWidth(List<T> list,ArCreator<T,? extends Number> creator,int span) throws Exception
   /**Calcule la plage de fluctuation de la valeur obtenue à partir des éléments de la liste de la plage précédente et l'écrit dans la liste d'origine.*/
   public static <T> void fluctuationWidth(List<T> list,ArCreator<T,? extends Number> creator,int span,String updateField) throws Exception 
   /**Calculer la valeur en pourcentage de la valeur obtenue à partir des éléments de List*/
   public static <T> List<Double> percent(List<T> list,ArCreator<T,? extends Number> creator) throws Exception
   /**Calculez la valeur en pourcentage de la valeur obtenue à partir des éléments de la liste et écrivez-la dans la liste d'origine*/
   public static <T> void percent(List<T> collection,ArCreator<T,? extends Number> creator,String updateField) throws Exception 
   /**Calculer la valeur cumulée des valeurs obtenues à partir des éléments de List*/
   public static <T> List<? extends Number> accumulation(List<T> list,ArCreator<T,? extends Number> creator) throws Exception 
   /**Calculer la valeur totale de l'intervalle de portée des valeurs obtenues à partir des éléments de List*/
   public static <T> List<? extends Number> periodSumarize(List<T> list,ArCreator<T,? extends Number> creator,int span) throws Exception

Histogramme des valeurs de liste

□ Créez un histogramme des valeurs obtenues à partir des éléments de List

ArList.java


   /**Créer un histogramme des valeurs extraites des éléments de la liste*/
   public static <T0,T1> int[] histogram(Collection<T0> collection,ArCreator<T0,T1> creator,ArValidator<T1>[] validators) throws Exception

Conversion de valeur à l'aide de deux listes

ArList.java


  /**Analyse la première liste à la recherche de l'index de la valeur spécifiée et renvoie la valeur de l'index ci-dessus dans la liste suivante*/
  public static <T0,T1> T1 getPartner(List<T0> orgValues,List<T1> desValues,T0 org)

Jugement de valeur égale de List et (List, Set, array) (valeur nulle ignorée, valeur en double ignorée, ordre ignoré possible)

□ Jugement de valeur égale de List et (List, Set, array)

ArList.java


   /**Jugement de valeur égal de deux listes*/
   public static <T> boolean equals(List<T> list0,List<T> list1)
   /**Jugement de valeur égal de deux listes.Ignorer l'ordre, ignorer la valeur nulle, ignorer la valeur en double peut être spécifié*/
   public static <T> boolean equals(List<T> list0,List<T> list1,ArSeqIgnore arSeq,ArNullIgnore arNull,ArDuplicateIgnore arDup) 
   /**Jugement équivalent de la liste et du tableau.Ignorer l'ordre, ignorer la valeur nulle, ignorer la valeur en double peut être spécifié*/
   public static <T> boolean equals(List<T> list0,T[] array1,ArSeqIgnore arSeq,ArNullIgnore arNull,ArDuplicateIgnore arDup) 
   /**Jugement de valeur égale de la liste et de l'ensemble.Vous pouvez spécifier la valeur nulle ignorer et la valeur dupliquée ignorer*/
   public static <T> boolean equals(List<T> list0,Set<T> set1,ArNullIgnore arNull,ArDuplicateIgnore arDup)

Définir le fonctionnement de deux listes (ET, OU, XOR, SAUF)

□ Rechercher AND, OR, XOR, SAUF de deux listes

ArList.java


   /**Trouvez le ET de deux listes*/
   public static <T> List<T> and(List<T> list0,List<T> list1)
   /**Trouvez le OU de deux listes*/
   public static <T> List<T> or(List<T> list0,List<T> list1)
   /**Trouvez le XOR de deux listes*/
   public static <T> List<T> xor(List<T> list0,List<T> list1) 
   /**Trouvez le SAUF de deux listes*/
   public static <T> List<T> except(List<T> list0,List<T> list1)

Définir le traitement associé (ArSet) (01)

Aperçu

Generate Set (à partir de Set, List, array, CSV string)

ArSet.java


  /**Correspondance qui Clone Set, non clonable comme Set*/
  public static <T> Set<T> clone(Set<T> set)
  /**Générer l'ensemble à partir de la liste*/
  public static <T> Set<T> constructFromList(List<T> list) 
  /**Générer l'ensemble à partir du tableau*/
  public static <T> Set<T> constructFromArray(T[] array)
  /**Générer l'ensemble à partir d'une chaîne CSV*/
  public static Set<String> construct(String str,char sep) 
  /**Générer l'ensemble à partir d'une chaîne CSV*/
  public static Set<String> construct(String str)
  /**Générer l'ensemble à partir du tableau int*/
  public static Set<Integer> constructFromIntArray(int[] intArray)
  /**Générer un ensemble de nombres à intervalles réguliers*/
  public static Set<Integer> construct(int start,int count,int step)

Extraire la valeur de Set

□ Créez un nouvel ensemble en extrayant les valeurs spécifiées (non spécifiées) dans le tableau à partir de Set

ArSet.java


  /**Crée un nouvel ensemble en extrayant les valeurs spécifiées dans le tableau à partir de Set*/
  public static <T> Set<T> select(Set<T> set,T[] array)
  /**Créer un nouvel ensemble en extrayant les valeurs non spécifiées dans le tableau à partir de l'ensemble*/
  public static <T> Set<T> selectExcept(Set<T> set,T[] array)

□ Extraire la valeur spécifiée (non spécifiée) par ArValidator de Set et créer un nouvel Set

ArSet.java


  /**Créer un nouvel ensemble en extrayant la valeur spécifiée par ArValidator de l'ensemble*/
  public static <T> Set<T> select(Set<T> set,ArValidator<T> validator)
  /**Créer un nouvel ensemble en extrayant des valeurs non spécifiées par ArValidator à partir de l'ensemble*/
  public static <T> Set<T> selectExcept(Set<T> set,ArValidator<T> validator)

□ Créez un nouvel ensemble en supprimant la valeur nulle de l'ensemble

ArSet.java


  /**Créer un nouvel ensemble en supprimant la valeur nulle de l'ensemble*/
  public static <T> Set<T> removeNull(Set<T> set)

Définir la conversion de valeur, conversion de type

ArSet.java


  /**Convertissez la valeur de Set en spécifiant les anciennes et les nouvelles valeurs dans Map, la valeur non spécifiée reste la même*/
  public static <T> void changeValue(Set<T> set,Map<T,T> map) 
  /**Créez un nouvel ensemble en spécifiant les anciennes et les nouvelles valeurs dans la carte, le type d'ensemble est également converti*/
  public static <T0,T1> Set<T1> changeValueType(Set<T0> set,ArCreator<T0,T1> creator) throws Exception

Conversion de l'ensemble vers d'autres formats

ArSet.java


  /**Convertir l'ensemble en carte, la clé spécifie le champ d'élément*/
  public static <T0,T1> Map<T1,T0> createMap(Collection<T0> collection,String keyField) throws Exception
  /**Convertir l'ensemble en carte, la clé est générée à partir de l'élément avec ArCreator*/
  public static <T0, T1, T2> Map<T1,T2> createMap(Collection<T0> collection,ArCreator<T0,T1> creator1,ArCreator<T0,T2> creator2) throws Exception 
  /**Convertir l'ensemble en ArMatrix, la clé spécifie le champ d'élément*/
  public static <T0, T1, T2> ArMatrix<T0,T1,T2> createArMatrix(Collection<T2> collection,String key0Field,String key1Field) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InvocationTargetException
  /**Convertir l'ensemble en ArMatrix, générer la clé à partir de l'élément avec ArCreator*/
  public static <T0,T1,T2> ArMatrix<T0,T1,T2> createArMatrix(Collection<T2> collection,ArCreator<T2,T0> key0Creator,ArCreator<T2,T1> key1Creator) throws Exception 
  /**Définir sur MapOnMap(Carte en deux étapes)Convertir en, clé spécifie le champ de l'élément*/
  public static  <T0,T1,T2> Map<T0,Map<T1,T2>> createMapOnMap(Collection<T2> collection,String key0Field,String key1Field) throws Exception
  /**Définir sur MapOnMap(Carte en deux étapes)Convertir en élément de génération de clé dans ArCreator*/
  public static  <T0,T1,T2> Map<T0,Map<T1,T2>> createMapOnMap(Collection<T2> collection,ArCreator<T2,T0> key0Creator,ArCreator<T2,T1> key1Creator) throws Exception
  /**Convertir l'ensemble d'entiers en tableau int*/
  public static int[] integerSetToIntArray(Set<Integer> integerSet)

Vérifier l'existence de la valeur de Set

ArSet.java


  /**Déterminez s'il n'y a qu'une seule valeur dans l'ensemble qui correspond à ArValidator*/
  public static <$Element> boolean containsOnlyOne(Collection<$Element> list,ArValidator<$Element> validator) 
  /**Déterminez s'il existe une valeur dans Set qui correspond à ArValidator*/
  public static <T> boolean contains(Collection<T> collection,ArValidator<T> validator)
  /**Déterminez s'il y a des valeurs dans Set qui correspondent à ArValidator*/
  public static <$Element> boolean containsNone(Collection<$Element> list,ArValidator<$Element> validator)
  /**Déterminez si toutes les valeurs de Set correspondent à ArValidator*/
  public static <$Element> boolean containsAll(Collection<$Element> list,ArValidator<$Element> validator)

Calcul des valeurs agrégées des valeurs définies (valeur maximale, valeur minimale, valeur totale, valeur moyenne, écart type)

ArSet.java


  /**Convertissez les éléments de Set en nombres avec ArCreator et calculez la valeur minimale*/
  public static <T> Number min(Collection<T> set,ArCreator<T,? extends Number> creator) throws Exception
  /**Convertissez les éléments de Set en valeurs numériques avec ArCreator et calculez la valeur maximale*/
  public static <T> Number max(Collection<T> set,ArCreator<T,? extends Number> creator) throws Exception
  /**Convertissez les éléments de Set en nombres avec ArCreator et calculez la valeur totale*/
  public static <T> Number sum(Collection<T> set,ArCreator<T,? extends Number> creator) throws Exception 
  /**Convertissez les éléments de Set en valeurs numériques avec ArCreator et calculez la valeur moyenne*/
  public static <T> Double avg(Collection<T> collection,ArCreator<T,? extends Number> creator) throws Exception 
  /**Convertissez les éléments de Set en valeurs numériques avec ArCreator et l'écart type*/
  public static <T> Double standardDeviation(Collection<T> collection,ArCreator<T,? extends Number> creator) throws Exception

Création d'un histogramme des valeurs définies

ArSet.java


  /**Créer un histogramme des valeurs obtenues à partir des éléments de Set*/
  public static <T0,T1> int[] histogram(Collection<T0> collection,ArCreator<T0,T1> creator,ArValidator<T1>[] validators) throws Exception

Réglez le fonctionnement de deux ensembles (ET, OU, XOR, SAUF)

ArSet.java


  /**Trouvez le ET de deux ensembles*/
  public static <T> Set<T> and(Set<T> set0,Set<T> set1) 
  /**Trouvez le OU de deux ensembles*/
  public static <T> Set<T> or(Set<T> set0,Set<T> set1) 
  /**Trouvez le XOR de deux ensembles*/
  public static <T> Set<T> xor(Set<T> set0,Set<T> set1)
  /**Trouvez le SAUF de deux ensembles*/
  public static <T> Set<T> except(Set<T> set0,Set<T> set1)

Jugement de valeur égale et jugement d'inclusion de deux ensembles

ArSet.java


  /**Jugement de valeur égal de deux ensembles*/
  public static <T> boolean equals(Set<T> set0,Set<T> set1) 
  /**Vous pouvez spécifier d'ignorer les valeurs nulles, ce qui détermine l'égalité de deux ensembles.*/
  public static <T> boolean equals(Set<T> set0,Set<T> set1,ArNullIgnore arNull)
  /**Vous pouvez spécifier d'ignorer les valeurs nulles et d'ignorer les valeurs en double pour déterminer l'égalité de Set et List.*/
  public static <T> boolean equals(List<T> list0,Set<T> set1,ArNullIgnore arNull,ArDuplicateIgnore arDup)
  /**Vous pouvez spécifier d'ignorer les valeurs nulles et d'ignorer les valeurs en double, ce qui détermine l'équivalence de Set et array.*/
  public static <T> boolean equals(Set<T> set0,T[] array1,ArNullIgnore arNull,ArDuplicateIgnore arDup)

Traitement lié à la carte (ArMap) (02)

Aperçu

Génération de mappage à partir de (Map, Collection, Csv, Tagged Csv, array, two-dimension array)

ArMap.java


  /**Clone Map, supporte que la carte elle-même n'est pas clonable*/
  public static <$Key, $Value> Map<$Key,$Value> clone(Map<$Key,$Value> map) 
  /**Générer la carte à partir de la collection, la clé est le champ spécifié*/
  public static <$Key, $Value> Map<$Key,$Value> constructFromCollection(Collection<$Value> collection,String keyField) throws Exception 
  /**Générer la carte à partir de la collection, la clé est générée par ArCreator*/
  public static <$Key,$Value> Map<$Key,$Value> constructFromCollection(Collection<$Value> collection,ArCreator<$Value,$Key> creator) throws Exception 
  /**Générer la carte à partir de la chaîne de caractères CSV, spécifier la clé comme tableau, spécifier le séparateur*/
  public static Map<String,String> constructFromCsv(String str,char sep,String[] keys) 
  /**Vous pouvez spécifier un séparateur qui génère une carte à partir d'une chaîne de caractères CSV balisés.*/
  public static Map<String,String> constructFromTaggedCsv(String str,ArCsvConf conf) 
  /**Générer la carte à partir d'une chaîne de caractères CSV balisée, le séparateur est égal à la virgule*/
  public static Map<String,String> constructFromTaggedCsv(String str) 
  /**Générer une carte à partir de deux tableaux*/
  public static <$Key, $Value> Map<$Key,$Value> construct($Key[] keys,$Value[] values) 
  /**Générer une carte à partir d'un tableau à deux dimensions*/
  public static <T> Map<T,T> construct(T[][] keysAndValues)
  /**Générer une carte à partir d'un tableau à deux dimensions*/
  public static <T> Map<T,T> construct(T[][] keysAndValues,int keyIndex,int valueIndex)

Mapper les paramètres de valeur (extraire les clés et les valeurs des objets)

Mapper le jugement d'égalité (désignation de la clé d'exclusion de jugement)

ArMap.java


  /**Tous les éléments des deux cartes(Clé et valeur)Déterminer si sont égaux*/
  public static <$Key, $Value> Boolean equals(Map<$Key,$Value> map0,Map<$Key,$Value> map1)
  /**Éléments clés spécifiés de deux cartes(Clé et valeur)Déterminer si sont égaux*/
  public static <$Key, $Value> Boolean equalsByKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1,Set<$Key> keys) 
  /**Éléments clés spécifiés de deux cartes(Clé et valeur)Déterminer si sont égaux*/
  public static <$Key, $Value> Boolean equalsByKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1,$Key[] keys)
  /**Éléments autres que la clé spécifiée des deux cartes(Clé et valeur)Déterminer si sont égaux*/
  public static <$Key, $Value> Boolean equalsExceptKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1,Set<$Key> keys) 
  /**Éléments autres que la clé spécifiée des deux cartes(Clé et valeur)Déterminer si sont égaux*/
  public static <$Key, $Value> Boolean equalsExceptKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1,$Key[] keys)

Jugement d'inclusion de carte (désignation de la clé d'exclusion de jugement)

ArMap.java


  /**map0 est tous les éléments de map1(Clé et valeur)Déterminez s'il contient*/
  public static <$Key, $Value> Boolean contains(Map<$Key,$Value> map0,Map<$Key,$Value> map1) 
  /**Map est un élément autre que la clé spécifiée de map1(Clé et valeur)Déterminez s'il contient*/
  public static <$Key, $Value> Boolean containsExceptKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1,Set<$Key> keys)
  /**Map est un élément autre que la clé spécifiée de map1(Clé et valeur)Déterminez s'il contient*/
  public static <$Key, $Value> Boolean containsExceptKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1,$Key[] keys)

Extraction des éléments de la carte (spécification de la valeur et des conditions clés)

□ Créer une nouvelle carte en excluant les valeurs nulles

ArMap.java


  /**Créer une nouvelle carte excluant les valeurs nulles*/
  public static <$Key, $Value> Map<$Key,$Value> selectNullExcept(Map<$Key,$Value> map)

□ Créez une nouvelle carte en extrayant avec la clé spécifiée

ArMap.java


  /**Créer une nouvelle carte en extrayant avec la clé spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByKey(Map<$Key,$Value> map,$Key[] keys) 
  /**Créer une nouvelle carte en extrayant avec la clé spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByKey(Map<$Key,$Value> map,Set<$Key> keys) 
  /**Créer une nouvelle carte en extrayant avec la clé spécifiée*/
  public static <$Key, $Value> Map<$Key,$Value> selectByKey(Map<$Key,$Value> map,ArValidator<$Key> validator)

□ Créez une nouvelle carte en extrayant avec une clé autre que celle spécifiée

ArMap.java


  /**Créer une nouvelle carte en extrayant avec une clé autre que celle spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByKeyExcept(Map<$Key,$Value> map,$Key[] keys) 
  /**Créer une nouvelle carte en extrayant avec une clé autre que celle spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByKeyExcept(Map<$Key,$Value> map,Set<$Key> keys) 
  /**Créer une nouvelle carte en extrayant avec une clé autre que celle spécifiée*/
  public static <$Key, $Value> Map<$Key,$Value> selectByKeyExcept(Map<$Key,$Value> map,ArValidator<$Key> validator)

□ Créez une nouvelle carte en extrayant les éléments contenant la valeur spécifiée

ArMap.java


  /**Créer une nouvelle carte en extrayant les éléments contenant la valeur spécifiée*/
  public static <$Key, $Value> Map<$Key,$Value> selectByValue(Map<$Key,$Value> map,$Value element) 
  /**Créer une nouvelle carte en extrayant les éléments contenant la valeur spécifiée*/
  public static <$Key, $Value> Map<$Key,$Value> selectByValue(Map<$Key,$Value> map,ArValidator<$Value> validator)
  /**Créer une nouvelle carte en extrayant les éléments contenant la valeur spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByValue(Map<$Key,$Value> map,Collection<$Value> values) 
  /**Créer une nouvelle carte en extrayant les éléments contenant la valeur spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByValue(Map<$Key,$Value> map,$Value[] values)

□ Créez une nouvelle carte en extrayant des éléments qui ne contiennent pas la valeur spécifiée

ArMap.java


  /**Créer une nouvelle carte en extrayant des éléments qui ne contiennent pas la valeur spécifiée*/
  public static <$Key, $Value> Map<$Key,$Value> selectByValueExcept(Map<$Key,$Value> map,ArValidator<$Value> validator)
  /**Créer une nouvelle carte en extrayant des éléments qui ne contiennent pas la valeur spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByValueExcept(Map<$Key,$Value> map,Collection<$Value> values) 
  /**Créer une nouvelle carte en extrayant des éléments qui ne contiennent pas la valeur spécifiée*/
  public static <$Key,$Value> Map<$Key,$Value> selectByValueExcept(Map<$Key,$Value> map,$Value[] values)

Extraction de clé de mappage (valeur, spécification de condition de clé)

□ Extraire la clé avec la valeur spécifiée

ArMap.java


  /**Extraire la clé avec la valeur spécifiée*/
  public static <$Key,$Value> Set<$Key> getKeysFromValue(Map<$Key,$Value> map,ArValidator<$Value> validator)
  /**Extraire la clé avec la valeur spécifiée*/
  public static <$Key,$Value> Set<$Key> getKeysFromValue(Map<$Key,$Value> map,Collection<$Value> coll) 
  /**Extraire la clé avec la valeur spécifiée*/
  public static <$Key,$Value> Set<$Key> getKeysFromValue(Map<$Key,$Value> map,$Value[] array)

□ Extraire la clé avec une valeur autre que la valeur spécifiée

ArMap.java


  /**Extraire la clé avec une valeur autre que la valeur spécifiée*/
  public static <$Key,$Value> Set<$Key> getKeysFromValueExcept(Map<$Key,$Value> map,ArValidator<$Value> validator) 
  /**Extraire la clé avec une valeur autre que la valeur spécifiée*/
  public static <$Key,$Value> Set<$Key> getKeysFromValueExcept(Map<$Key,$Value> map,Collection<$Value> coll) 
  /**Extraire la clé avec une valeur autre que la valeur spécifiée*/
  public static <$Key,$Value> Set<$Key> getKeysFromValueExcept(Map<$Key,$Value> map,$Value[] array)

Opération de jeu de cartes (AND, OR, XOR, EXCEPT)

□ Créez une nouvelle carte en effectuant une opération d'ensemble de deux cartes

ArMap.java


  /**Créer une nouvelle carte en ANDing les clés de deux cartes*/
  public static <$Key,$Value> Map<$Key,$Value> andKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1)
  /**Créer une nouvelle carte en ANDing la clé et la valeur de deux cartes*/
  public static <$Key,$Value> Map<$Key,$Value> andValue(Map<$Key,$Value> map0,Map<$Key,$Value> map1,ArComparator<$Value> comparator) throws InstantiationException, IllegalAccessException
  /**Créer une nouvelle carte avec XOR de deux cartes*/ 
  public static <$Key, $Value> Map<$Key,$Value> xor(Map<$Key,$Value> map0,Map<$Key,$Value> map1)
  /**Créer une nouvelle carte à l'exception des deux clés de la carte*/ 
  public static <$Key, $Value> Map<$Key,$Value> exceptKey(Map<$Key,$Value> map0,Map<$Key,$Value> map1)
  /**Créer une nouvelle carte à l'exception de la clé et de la valeur de deux cartes*/
  public static <$Key,$Value> Map<$Key,$Value> exceptValue(Map<$Key,$Value> map0,Map<$Key,$Value> map1,ArComparator<$Value> comparator)

Conversion de valeur de clé de mappage

□ Convertir la clé de la carte en une autre valeur

ArMap.java


  /**Convertir la clé de la carte en une autre valeur*/
  public static <$Key, $Value> Map<$Key,$Value> changeKey(Map<$Key,$Value> map,Map<$Key,$Key> keyMap) 
  /**Convertir la clé de la carte en une autre valeur*/
  public static <$Key,$Value> Map<$Key,$Value> changeKey(Map<$Key,$Value> map,$Key[] oldKeys,$Key[] newKeys)
  /**Convertir la clé de la carte en une autre valeur*/
  public static <$Key,$Value> Map<$Key,$Value> changeKey(Map<$Key,$Value> map,$Key[][] keys)

Conversion de valeur de carte, conversion de type de valeur

□ Convertir les valeurs de la carte

ArMap.java


  /**Convertir les valeurs de la carte*/
  public static  <$value,$key> void changeValue(Map<$key,$value> map,Map<$value,$value> valueMap)

□ Convertissez le type de valeur de la carte pour créer une nouvelle carte

ArMap.java


  /**Créer une nouvelle carte en convertissant le type de valeur de la carte*/
  public static <$Key,$Value,$NewValue> Map<$Key,$NewValue> changeValueType(Map<$Key,$Value> map,Map<$Value,$NewValue> valueMap) throws Exception 
  /**Créer une nouvelle carte en convertissant le type de valeur de la carte*/
  public static <$Key,$Value,$NewValue> Map<$Key,$NewValue> changeValueType(Map<$Key,$Value> map,ArCreator<$Value,$NewValue> creator) throws Exception

Calcul des valeurs agrégées de la carte (valeur minimale, valeur maximale, valeur totale, valeur moyenne, écart type)

□ Calculez la valeur agrégée à partir de la valeur de la carte

ArMap.java


  /**Calculer la valeur maximale à partir de la valeur de Map*/
  public static <$KeyT> Number max(Map<$KeyT,? extends Number> map) 
  /**Calculer la valeur minimale à partir de la valeur de Map*/
  public static <$Key> Number min(Map<$Key,? extends Number> map) 
  /**Calculez la valeur totale à partir de la valeur de Map*/
  public static <$Key> Number sum(Map<$Key,? extends Number> map)
  /**Calculer la valeur moyenne à partir de la valeur de Map*/
  public static <$Key> Double avg(Map<$Key,? extends Number> map)
  /**Calculer la valeur minimale à partir de la valeur de Map*/
  public static  <$Key, $Value> Number min(Map<$Key,$Value> map,ArCreator<$Value,? extends Number> creator) throws Exception 
  /**Calculer la valeur maximale à partir de la valeur de Map*/
  public static <$Key, $Value> Number max(Map<$Key,$Value> map,ArCreator<$Value,? extends Number> creator) throws Exception
  /**Calculez la valeur totale à partir de la valeur de Map*/
  public static <$Key, $Value> Number sum(Map<$Key,$Value> map,ArCreator<$Value,? extends Number> creator) throws Exception 
  /**Calculer la valeur moyenne à partir de la valeur de Map*/
  public static <$Key, $Value> Double avg(Map<$Key,$Value> map,ArCreator<$Value,? extends Number> creator) throws Exception

Autre traitement de la carte

ArMap.java


  /**Inverser les clés et les valeurs de la carte*/
  public static <$Key,$Value> Map<$Value,$Key> reverse(Map<$Key,$Value> map) {
  /**Ajouter, soustraire, multiplier, diviser la valeur de Map dont la valeur est Integer*/
  public static <$Key> int calc(Map<$Key,Integer> map,$Key key,ArCalc op,Integer value)

Traitement lié aux baies (ArArray) (03)

Aperçu

Déterminer l'existence de valeurs de tableau, convertir des valeurs à l'aide de deux tableaux

□ Renvoie l'index de la valeur spécifiée

ArArray.java


  /**Renvoie l'index de l'élément spécifié.S'il n'existe pas, la taille sera égale à zéro.. */
  public static <T> List<Integer> getIndexes(T[] list,T element)
  /**Renvoie l'index de l'élément spécifié.S'il n'existe pas, la taille sera égale à zéro.. */
  public static <T> List<Integer> getIndexes(T[] list,ArValidator<T> validator)

□ Conversion de valeur à l'aide de deux tableaux

ArArray.java


  /**Trouvez l'index qui correspond à org à partir de orgValues et renvoyez l'élément correspondant dans desValues.   */
  public static <T0,T1> T1 getPartner(T0[] orgValues,T1[] desValues,T0 org,ArComparator comparator) 
  /**Trouvez l'index qui correspond à org à partir de orgValues et renvoyez l'élément correspondant dans desValues.  */
  public static <T1> T1 getPartner(int[] orgValues,T1[] desValues,Integer org,ArComparator comparator) 
  /**Trouvez l'index qui correspond à org à partir de orgValues et renvoyez l'élément correspondant dans desValues.  */
  public static <T0> Integer getPartner(T0[] orgValues,int[] desValues,T0 org,ArComparator comparator) 
  /** valuesArray[][orgIndex]Trouvez celui qui correspond à l'organisation à partir des valeurs[][desIndex]Renvoie la valeur de.   */
  public static <T> T getPartner(T[][] valuesArray,int orgIndex,int desIndex,T org) 
  /** valuesArray[][orgIndex]Trouvez celui qui correspond à l'organisation à partir des valeurs[][desIndex]Renvoie la valeur de.   */
  public static int getPartner(int[][] valuesArray,int orgIndex,int desIndex,int org)

Comptage des valeurs de tableau, vérification des doublons

□ Déterminez s'il y a des valeurs en double dans le tableau

ArArray.java


  /**Rechercher les doublons dans le tableau*/
  public static <T> boolean duplicated(T... array)

□ Comptez le nombre de valeurs spécifiées dans le tableau

ArArray.java


  /**Compter le nombre d'éléments spécifiés dans le tableau. */
  public static <T> int count(T[] array,T element)
  /**Compter le nombre d'éléments spécifiés dans le tableau. */
  public static <T> int count(T[] array,ArValidator<T> validator)

□ Renvoie l'index de la valeur spécifiée dans le tableau

ArArray.java

Jugement de l'existence de la valeur nulle du tableau, acquisition de l'indice

□ Déterminez s'il y a une valeur nulle dans le tableau

ArArray.java

□ Déterminez si toutes les valeurs du tableau sont (non) nulles

ArArray.java


  /**Renvoie vrai si tous les arguments ne sont pas nuls.(Faux si même un est nul). */
  public static boolean allNotNull(Object... objs)

□ Déterminez si une seule valeur du tableau est (non) nulle

ArArray.java


  /**Renvoie vrai si un seul argument est nul. */
  public static boolean oneNull(Object... objs) 
  /**Renvoie vrai si un seul argument est non nul. */
  public static boolean oneNotNull(Object... objs)

□ Renvoie l'index de la valeur nulle dans le tableau

ArArray.java


  /**Renvoie l'index de la valeur nulle du tableau. */
  public static <T> List<Integer> getNullIndexes(T... values) {
  /**Vérifiez si le tableau contient null.Vrai si inclus.  */
  public static <T> boolean containsNull(T... array)

Changer le tableau Trier, inverser l'ordre, convertir les valeurs, remplacer le tableau à deux dimensions

□ Trier les tableaux comparables, au cas où vous ne voudriez pas spécifier de comparateur

ArArray.java


  /**Trier un tableau de comparables*/
  public static void sort(Comparable[] array,ArSortDir dir)

□ Permutez les deux éléments du tableau

ArArray.java


  /**Échangez les deux éléments*/
  public static <T> void swap(T[] array,int i0,int i1)

□ Inversez les éléments du tableau

ArArray.java


  /**Inverser les éléments*/
  public static <T> void reverse(T[] array)

□ Convertissez la valeur du tableau en une autre valeur spécifiée dans Map

ArArray.java


  /**Convertit une valeur de tableau en une autre valeur spécifiée dans Map.La valeur non spécifiée reste la même*/
  public static <T> void changeValue(T[] array,Map<T,T> map)

□ Supprimez la valeur nulle du tableau, elle sera retournée dans List, alors faites-en un tableau vous-même si nécessaire

ArArray.java


  /**Supprimer null du tableau.Notez que si vous souhaitez que la valeur de retour soit un tableau, l'appelant toArray(new String[]{})Faire.  */
  public static <T> List<T> removeNull(T... values)

□ Permuter les tableaux bidimensionnels (M × N⇒N × M), int, double, chaîne uniquement

ArArray.java


  /**Permuter des tableaux à deux dimensions(M×N⇒N×M) */
  public static int[][] exchange(int[][] array) 
  /**Permuter des tableaux à deux dimensions(M×N⇒N×M) */
  public static double[][] exchange(double[][] array) 
  /**Permuter des tableaux à deux dimensions(M×N⇒N×M) */
  public static String[][] exchange(String[][] array) {

Conversion du tableau en Set, List

ArArray.java


  /**set array<T>Convertir en. */
  public static <T> Set<T> toSet(T... array) throws InstantiationException, IllegalAccessException
  /** int[]Mettre en place. */
  public static Set<Integer> toSet(int[] args) 
  /**  int[]liste<Integer>Convertir en. */
  public static List<Integer> toList(int[] intArray) 
  /**
   *Faire du tableau une liste.<br>
   *Remarque, tableaux.asList est java.util.Arrays$Renvoie une ArrayList donc java.util.Implémenter pour renvoyer une ArrayList.<br>
   *Remarque, java.util.Arrays$ArrayList ne peut pas ajouter d'éléments.<br>
   */
  public static <T> List<T> toList(T... array)

Conversion d'un tableau en carte

ArArray.java


  /**Générer une carte à partir de deux tableaux. */
  public static <T0, T1> Map<T0,T1> toMap(T0[] keys,T1[] values) 
  /**
   *Générer une carte à partir d'un tableau à deux dimensions.
   *  keysAndValues[0]Est la clé, keysAndValues[1]Devient la valeur.
   */
  public static <T> Map<T,T> toMap(T[][] keysAndValues) 
  /**Créer une carte à partir d'un tableau à deux dimensions.  */
  public static <T> Map<T,T> toMap(T[][] keysAndValues,int keyIndex,int valueIndex) {

Conversion entre tableau et Csv balisé

ArArray.java


  /**
   *  TaggedCsv(Chaîne de format)Vers deux tableaux.
   *  @return Object[0]Est une chaîne[]Dans un tableau de noms de champs, Object[1]Est une chaîne[]Tableau de valeurs dans.
   */
  public static Object[] fromTaggedCsvToTwoArrays(String taggedCsv,ArCsvConf conf) 
  /**
   *  TaggedCsv(Chaîne de format)Vers un tableau à deux dimensions.
   *  @return Tableau converti.[][0]Est le nom du champ,[][1]Est la valeur.
   */
  public static String[][] fromTaggedCsvToTwoDimArray(String taggedCsv,ArCsvConf conf) 
  /**Csv étiqueté à partir d'un tableau à deux dimensions(Chaîne de format)Convertir en. */
  public static String fromTwoDimArrayToTaggedCsv(String[][] twoDimArray,ArCsvConf conf) 
  /**Csv étiqueté à partir de deux séquences(Chaîne de format)Convertir en. */
  public static String fromTwoArraysToTaggedCsv(String[] nameArray,String[] valueArray,ArCsvConf conf)

Jugement de valeur égale du tableau, List, Set Ignore null, ignore duplicate, ignore order

ArArray.java


 /**Déterminer si deux séquences sont égales.Si vous passez quelque chose qui n'est pas un tableau, vous obtiendrez une RuntimeException.   */
  public static boolean equals(Object obj0,Object obj1) 
  /**
   *Déterminer si deux séquences sont égales.
   *  @param arSeq Ignorer ou non l'ordre.S'il est IGNORE, il est jugé égal même si l'ordre est différent.
   *  @param arNull Ignorer ou non null.Si c'est IGNORE, sautez nul et jugez.
   *  @param arDup Voulez-vous ignorer les doublons?.S'il est IGNORE, il est jugé égal même s'il y a des doublons.
   */
  public static <T> boolean equals(T[] array0,T[] array1,ArSeqIgnore arSeq,ArNullIgnore arNull,ArDuplicateIgnore arDup) 
  /**
   *Déterminer si la liste et le tableau sont égaux.
   *  @param arSeq Ignorer ou non l'ordre.S'il est IGNORE, il est jugé égal même si l'ordre est différent.
   *  @param arNull Ignorer ou non null.Si c'est IGNORE, sautez nul et jugez.
   *  @param arDup Voulez-vous ignorer les doublons?.S'il est IGNORE, il est jugé égal même s'il y a des doublons.
   */
  public static <T> boolean equals(List<T> list0,T[] array1,ArSeqIgnore arSeq,ArNullIgnore arNull,ArDuplicateIgnore arDup) 
  /**
   *Déterminer si l'ensemble et le tableau sont égaux.
   *  @param arNull Ignorer ou non null.Si c'est IGNORE, sautez nul et jugez.
   *  @param arDup Voulez-vous ignorer les doublons?.S'il est IGNORE, il est jugé égal même s'il y a des doublons.
   */
  public static <T> boolean equals(Set<T> set0,T[] array1,ArNullIgnore arNull,ArDuplicateIgnore arDup)

Jugement de la relation d'inclusion entre deux séquences

ArArray.java


  /**Vérification d'inclusion.Vérifiez si tous les éléments du tableau B sont inclus dans le tableau A. */
  public static <T> Boolean contains(T[] arrayA,T... arrayB)
  /**Vérification d'inclusion.Vérifiez si l'un des éléments du tableau B n'est pas inclus dans le tableau A. */
  public static <T> Boolean notContains(T[] arrayA,T... arrayB) 
  /**Vérification d'inclusion.Vérifiez si tous les éléments du tableau B sont contenus dans le tableau A. */
  public static Boolean contains(int[] arrayA,int[] arrayB) 
  /**Vérification d'inclusion.Vérifiez si l'une des séquences B n'est pas incluse dans la séquence A.  */
  public static Boolean notContains(int[] arrayA,int[] arrayB) 
  /**Vérification d'inclusion.Vérifiez si tous les éléments du tableau B sont inclus dans le tableau A. */
  public static Boolean contains(long[] arrayA,long[] arrayB) {
  /**Vérification d'inclusion.Vérifiez si l'une des séquences B n'est pas incluse dans la séquence A. */
  public static Boolean notContains(long[] arrayA,long[] arrayB) {

Réflexion de tableau (qu'il s'agisse d'un tableau, qu'il s'agisse d'un élément d'un tableau, qu'il s'agisse d'une primitive ou non)

ArArray.java


  /**Juger s'il s'agit d'un tableau.Renvoie null si nul. */
  public static Boolean isArray(Object obj) 
  /**Extraire le type d'éléments dans un tableau.obj doit être un tableau.Renvoie null si ce n'est pas un tableau.  */
  public static Class getArrayComponentType(Object obj) 
  /**Déterminer si les éléments du tableau sont des types primitifs.Renvoie null si obj n'est pas un tableau. */
  public static Boolean arrayComponentIsPrimitive(Object obj)

Traitement des tableaux numériques (ArMath) (04)

Aperçu

Cette classe traite principalement des tableaux doubles.

Génération et configuration de tableaux numériques unidimensionnels et bidimensionnels

□ Définissez une valeur dans un tableau double unidimensionnel existant qui génère un tableau double unidimensionnel

ArMath.java


  /**Génération d'un tableau unidimensionnel*/
  public static double[] doubleArray(int size,ArGenerator<Double> generator)
  /**Génération d'un tableau unidimensionnel,L'index du tableau est spécifié dans l'argument du créateur. */
  public static double[] doubleArray(int size,ArCreator<Integer,Double> creator) throws Exception 
  /**Paramètre de tableau unidimensionnel*/
  public static void fill(double[] doubleArray,ArGenerator<Double> generator) 
  /**Paramètre de tableau unidimensionnel.L'index du tableau est spécifié dans l'argument du créateur. */
  public static void fill(double[] doubleArray,ArCreator<Integer,Double> creator) throws Exception

□ Définissez une valeur pour un tableau double bidimensionnel existant qui génère un tableau double bidimensionnel

ArMath.java


  /**Génération d'un tableau bidimensionnel*/
  public static double[][] doubleArray2D(int sizeRow,int sizeCol,ArGenerator<Double> generator)
  /**Génération de tableaux bidimensionnels L'index du tableau est spécifié dans l'argument du créateur.*/
  public static double[][] doubleArray2D(int sizeRow,int sizeCol,ArCreator2d<Integer,Integer,Double> creator) throws Exception 
  /**Paramètre de tableau bidimensionnel*/
  public static void fill(double[][] doubleArray2D,ArGenerator<Double> generator) 
  /**Paramètre de tableau bidimensionnel.L'index du tableau est spécifié dans l'argument du créateur. */
  public static void fill(double[][] doubleArray2D,ArCreator2d<Integer,Integer,Double> creator) throws Exception

Conversion de format de tableau numérique Extraction de lignes et de colonnes de tableaux en deux dimensions, conversion unidimensionnelle ⇔ bidimensionnelle

□ Extraction de lignes et de colonnes d'un tableau à deux dimensions

ArMath.java


  /**Extraction de lignes et de colonnes d'un tableau à deux dimensions*/
  public static double[] extract(double[][] doubleArray,int index,ArTableRC rowCol)

□ Échange de lignes / colonnes d'un tableau à deux dimensions

ArMath.java


  /**Ligne de tableau à deux dimensions/Échange de colonnes*/
  public static double[][] exchangeRowColumn(double[][] doubleArray)

□ Tableau à une dimension ⇔ Tableau à deux dimensions

ArMath.java


  /**Tableau à une dimension ⇒ Tableau à deux dimensions*/
  public static double[][] toTwoDim(double[] doubleArray,int colCount) 
  /**Tableau bidimensionnel ⇒ Tableau unidimensionnel*/
  public static double[] toOneDim(double[][] doubleArray)

Primitive de conversion de type tableau numérique ⇔ wrapper, int ⇔ Integer, etc.

□ int[] ⇔ Integer[]

ArMath.java


  /** int[]⇒Integer[] */
  public static Integer[] convertIntArrayToIntegerArray(int[] intArray) 
  /** Integer[]⇒int[] */
  public static int[] convertIntegerArrayToIntArray(Integer[] integerArray)

□ int[][] ⇔ Integer[][]

ArMath.java


  /** int[][]⇒Integer[][] */
  public static Integer[][] convertIntArray2dToIntegerArray2d(int[][] intArray2D) 
  /** Integer[][]⇒int[][] */
  public static int[][] convertIntegerArray2dToIntArray2d(Integer[][] integetArray2D)

□ double[] ⇔ Double[]

ArMath.java


  /** double[]⇒Double[] */
  public static Double[] convertDblArrayToDoubleArray(double[] doubleArray)
  /** Double[]⇒double[] */
  public static double[] convertDoubleArrayToDblArray(Double[] doubleArray)

□ double[][] ⇔ Double[][]

ArMath.java


  /** Double[]⇒double[] */
  public static double[] convertDoubleArrayToDblArray(Double[] doubleArray) 
  /** double[][]⇒Double[][] */
  public static Double[][] convertDblArray2dToDoubleArray2d(double[][] doubleArray2d)

□ int[] ⇔ double[]

ArMath.java


  /** int[]⇒double[] */
  public static double[] convertIntArrayToDblArray(int[] intArray) 
  /** double[]⇒int[] */
  public static int[] convertDblArrayToIntArray(double[] doubleArray) {

□ int[][] ⇔ double[][]

ArMath.java


  /** int[][]⇒double[][] */
  public static double[][] convertIntArray2dToDblArray2d(int[][] intArray2d) 
  /** double[][]⇒int[][] */
  public static int[][] convertDblArray2dToIntArray2d(double[][] doubleArray2d)

□ Extraire la colonne spécifiée du double [] []

ArMath.java


  /** double[][]Extraire la colonne spécifiée de*/
  public static double[] extract(double[][] array,int index)

□ Double liste ⇒ Double []

ArMath.java


  /** List<Double>Double[]Convertir en*/
  public static Double[] convertDoubleListToDblArray(List<Double> list)

Valeurs agrégées des valeurs de tableau numérique (valeur minimale, valeur maximale, valeur totale, valeur moyenne, écart type)

□ Valeur agrégée d'un tableau unidimensionnel et d'un tableau bidimensionnel

ArMath.java


  /**Agrégation d'un tableau unidimensionnel(Minimum maximum etc.) */
  public static double calc(double[] doubleArray,ArReduceTo kind)
  /**Agrégation d'un tableau bidimensionnel(Minimum maximum etc.) */
  public static double[] calc(double[][] doubleArray,ArReduceTo kind,ArTableRC rowCol) {

□ Calcul de la valeur maximale

ArMath.java


  /**Valeur maximum-collection-Integer.<br> */
  public static Integer max(Collection<Integer> values) 
  /**Valeur maximum-collection-double.<br> */
  public static Double maxDouble(Collection<Double> values) 
  /**Valeur maximum-Tableau-int.<br> */
  public static int max(int... values) 
  /**Valeur maximum-Tableau-double.<br> */
  public static double maxDouble(double... values)

□ Calcul de la valeur minimale

ArMath.java


  /**valeur minimum-collection-Integer.<br> */
  public static Integer min(Collection<Integer> values) 
  /**valeur minimum-collection-Double.<br> */
  public static Double minDouble(Collection<Double> values) 
  /**valeur minimum-Tableau-int.<br> */
  public static int min(int... values) 
  /**valeur minimum-Tableau-double.<br> */
  public static double minDouble(double... values)

□ Calcul de la valeur totale

ArMath.java


  /**Valeur totale-collection-Integer.<br> */
  public static Integer sum(Collection<Integer> values) 
  /**Valeur totale-collection-Double.<br> */
  public static Double sumDouble(Collection<Double> values) 
  /**Valeur totale-Tableau-int.<br> */
  public static Integer sum(int... values) 
  /**Valeur totale-Tableau-double.<br> */
  public static Double sumDouble(double... values)

□ Calcul de la valeur moyenne

ArMath.java


  /**Valeur moyenne-collection-Integer.<br> */
  public static double avg(Collection<Integer> values) 
  /**Valeur moyenne-collection-Double.<br> */
  public static double avgDouble(Collection<Double> values) 
  /**Valeur moyenne-Tableau-int.<br> */
  public static double avg(int... values) 
  /**Valeur moyenne-Tableau-double.<br> */
  public static double avgDouble(double... values)

□ Calcul de l'écart type

ArMath.java


  /**écart-type-collection-Integer.<br> */
  public static double stdDevi(Collection<Integer> values) 
  /**écart-type-collection-Double.<br> */
  public static double stdDeviDouble(Collection<Double> values) 
  /**écart-type-Tableau-int.<br> */
  public static double stdDevi(int... values) 
  /**écart-type-Tableau-double.<br> */
  public static double stdDeviDouble(double... values)

Extraction de valeurs par conditions (grandes et petites, etc.) à partir d'un tableau numérique

□ Extraire les éléments inférieurs à la valeur spécifiée (non inclus)

ArMath.java


  /** LessThan-collection-Integer. */
  public static List<Integer> ltSelect(Integer boundary,Collection<Integer> values) 
  /** LessThan-collection-Double. */
  public static List<Double> ltSelectDouble(Double boundary,Collection<Double> values) 
  /** LessThan-Tableau-int. */
  public static List<Integer> lessThan(int boundary,int... values) 
  /** LessThan-Tableau-double. */
  public static List<Double> ltSelectDouble(double boundary,double... values)

□ Extraire les éléments inférieurs à la valeur spécifiée (y compris)

ArMath.java


  /** LessEqual-collection-Integer. */
  public static List<Integer> leSelect(Integer boundary,Collection<Integer> values) 
  /** LessEqual-collection-Double. */
  public static List<Double> leSelectDouble(Double boundary,Collection<Double> values) 
  /** LessEqual-Tableau-int. */
  public static List<Integer> lessEqual(int boundary,int... values) 
  /** LessEqual-Tableau-double. */
  public static List<Double> leSelectDouble(double boundary,double... values)

□ Extraire les éléments plus grands que la valeur spécifiée (non inclus)

ArMath.java


  /** GreaterThan-collection-Integer. */
  public static List<Integer> gtSelect(Integer boundary,Collection<Integer> values) 
  /** GreaterThan-collection-Double. */
  public static List<Double> gtSelectDouble(Double boundary,Collection<Double> values) 
  /** GreaterThan-Tableau-int. */
  public static List<Integer> greaterThan(int boundary,int... values) 
  /** GreaterThan-Tableau-double. */
  public static List<Double> gtSelectDouble(double boundary,double... values)

□ Extraire les éléments plus grands que la valeur spécifiée (y compris)

ArMath.java


  /** GreaterEqual-collection-Integer. */
  public static List<Integer> geSelect(Integer boundary,Collection<Integer> values) 
  /** GreaterEqual-collection-Double. */
  public static List<Double> geSelectDouble(Double boundary,Collection<Double> values) 
  /** GreaterEqual-Tableau-int. */
  public static List<Integer> greaterEqual(int boundary,int... values) 
  /** GreaterEqual-Tableau-double. */
  public static List<Double> geSelectDouble(double boundary,double... values)

Ordre inverse du tableau numérique, randomiser

□ Ordre inverse du tableau numérique, randomiser

ArMath.java


  /**Ordre inverse du tableau unidimensionnel*/
  public static double[] reverse(double[] doubleArray) 
  /**Tableau aléatoire unidimensionnel*/
  public static double[] randomize(double[] doubleArray) 
  /**Ordre inverse des lignes et des colonnes d'un tableau à deux dimensions,l'index est-Quand 1 est tout une ligne ou une colonne*/
  public static double[][] reverse(double[][] doubleArray,int index,ArTableRC rowCol) 
  /**Randomiser les lignes et les colonnes d'un tableau à deux dimensions,l'index est-Quand 1 est tout une ligne ou une colonne*/
  public static double[][] randomize(double[][] doubleArray,int index,ArTableRC rowCol)

Calcul avec la valeur numérique spécifiée du tableau numérique

□ Calcul de la valeur numérique spécifiée du tableau numérique - Calcul du tableau entier

ArMath.java


  /**Conversion de tableau à une dimension*/
  public static double[] convert(double[] doubleArray,ArCalc kind,double value) 
  /**Conversion de tableau à une dimension*/
  public static double[] convert(double[] doubleArray,ArCreator<Double,Double> creator) throws Exception 
  /**Conversion de tableau à une dimension.L'index du tableau est spécifié dans l'argument Integer du créateur. */
  public static double[] convert(double[] doubleArray,ArCreator2d<Double,Integer,Double> creator) throws Exception 
  /**Conversion de tableau bidimensionnel*/
  public static double[][] convert(double[][] doubleArray,ArCalc kind,double value) 
  /**Conversion de tableau bidimensionnel*/
  public static double[][] convert(double[][] doubleArray,ArCreator<Double,Double> creator) throws Exception 
  /**Conversion de tableau bidimensionnel*/
  public static double[][] convert(double[][] doubleArray,ArCreator2d<Double,Integer,Double> creator) throws Exception

Calcul des valeurs de transition (moyenne mobile, etc.) d'un tableau numérique

□ Calcul des valeurs de transition (moyenne mobile, etc.) d'un tableau numérique

ArMath.java


  /**
   *Conversion numérique à l'aide d'ArConvertTo.Cependant, l'histogramme de kind ne peut pas être spécifié..
   *param n'a de sens que si.MOVING_AVG,CHANGE_RATE,CHANGE_WIDTH,PERIOD_SUM.
   *CHANGER aussi_RATE,CHANGE_Si 0 est spécifié pour param dans WIDTH, ce sera un changement par rapport à la valeur initiale..
   */
  public static double[] convert(double[] array,ArConvertTo kind,int param) throws Exception 
  /**
   *Conversion numérique à l'aide d'ArConvertTo.Cependant, l'histogramme de kind ne peut pas être spécifié..
   *param n'a de sens que si.MOVING_AVG,CHANGE_RATE,CHANGE_WIDTH,PERIOD_SUM.
   *CHANGER aussi_RATE,CHANGE_Si 0 est spécifié pour param dans WIDTH, ce sera un changement par rapport à la valeur initiale..
   */
  public static double[] convert(double[][] array,ArConvertTo kind,int param,ArTableRC rowCol,int index) throws Exception

Création d'un histogramme à partir d'un tableau numérique

□ Création d'un histogramme à partir d'un tableau numérique

ArMath.java


  /**
   *Créer un histogramme.longueur doudary-Une valeur de 1 est renvoyée.
   * boundary[0],boundary[length-1]Peut être nul.Dans ce cas, il est interprété comme une valeur infinie.
   */
  public static int[] histogram(double[] array,Double[] boundary) throws Exception 
  /**Créer un histogramme*/
  public static int[] histogram(double[] array,ArValidator<Double>[] validators) throws Exception

Calcul entre deux tableaux numériques

□ Calcul entre deux tableaux numériques

ArMath.java


  /**Arithmétique entre des tableaux à une dimension*/
  public static double[] calc(double[] doubleArray0,double[] doubleArray1,ArCalc kind) 
  /**Arithmétique entre des tableaux à une dimension*/
  public static double[] calc(double[] doubleArray0,double[] doubleArray1,ArCreator2d<Double,Double,Double> creator) throws Exception 
  /**Addition, soustraction, multiplication et division de lignes / colonnes d'un tableau à deux dimensions et d'un tableau à une dimension.Le tableau bidimensionnel d'origine est réécrit. */
  public static void calc(double[][] doubleArray0,double[] doubleArray1,int index,ArCalc kind,ArTableRC rowCol) 
  /**Opération de ligne / colonne de tableau à deux dimensions et de tableau à une dimension.Le tableau bidimensionnel d'origine est réécrit.*/
  public static void calc(double[][] doubleArray0,double[] doubleArray1,int index,ArCreator2d<Double,Double,Double> creator,ArTableRC rowCol) throws Exception

Traitement lié à la carte en deux étapes (ArMapOnMap) (05)

Aperçu

Génération d'une carte en deux étapes à partir de (Carte en deux étapes (Clone), Collection, ListOnMap, ArMatrix)

□ Clonez la carte en deux étapes

ArMapOnMap.java


  /**Cloner*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> clone(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) throws InstantiationException, IllegalAccessException

□ Générer une carte en deux étapes à partir d'ArMatrix

ArMapOnMap.java


  /**Key0 généré à partir d'ArMatrix->key1 */
  public static <$Key0,$Key1,$Value> Map<$Key0,Map<$Key1,$Value>> constructFromArMatrixKey0Key1(ArMatrix<$Key0,$Key1,$Value> mat) 
  /**Key1 généré à partir d'ArMatrix-key0 */
  public static <$Key0,$Key1,$Value> Map<$Key1,Map<$Key0,$Value>> constructFromArMatrixKey1Key0(ArMatrix<$Key0,$Key1,$Value> mat) throws InstantiationException, IllegalAccessException

□ Générer une carte en deux étapes à partir de ListOnMap

ArMapOnMap.java


  /**
   *Générer à partir de ListOnMap.La classe de la carte principale est la même classe que la ListOnMap originale.
   *Clé secondaire($Key1)Est la valeur($Value)Générer à partir du domaine de.
   *Si la clé secondaire générée est dupliquée pour la même clé primaire, les données ultérieures seront définies..
   */
  public static <$Key0,$Key1,$Value> Map<$Key0,Map<$Key1,$Value>> constructFromListOnMap(Map<$Key0,List<$Value>> listOnMap,String key1Field) throws Exception 
  /**
   *Générer à partir de ListOnMap
   *Clé secondaire($key1)Est la valeur($Value)Générer avec ArCreator depuis.
   *Si la clé secondaire générée est dupliquée pour la même clé primaire, les données ultérieures seront définies..
   */
  public static <$Key0,$Key1,$Value> Map<$Key0,Map<$Key1,$Value>> constructFromListOnMap(Map<$Key0,List<$Value>> listOnMap,ArCreator<$Value,$Key1> creator) throws Exception {

□ Générer une carte en deux étapes à partir de la collection

ArMapOnMap.java


  /**Générer à partir de la collection$key0,$key1 provient du champ spécifié. */
  public static <$Key0,$Key1,$Value> Map<$Key0,Map<$Key1,$Value>> constructFromCollection(Collection<$Value> collection,String key0Field,String key1Field) throws Exception
  /**Générer à partir de la collection$key0,$key1 est généré par ArCreator. */
  public static <$Key0, $Key1, $Value> Map<$Key0,Map<$Key1,$Value>> constructFromCollection(Collection<$Value> collection,ArCreator<$Value,$Key0> creator0,ArCreator<$Value,$Key1> creator1) throws Exception  {

Conversion de la valeur de la carte en deux étapes (spécifiez la valeur de conversion avec Map ou ArCreator)

□ Convertissez la valeur de la carte en deux étapes

ArMapOnMap.java


  /**Remplacez la valeur par la valeur spécifiée dans Map.La valeur non spécifiée reste la même. */
  public static <$PrimaryKey,$SecondaryKey,$Value> void changeValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,Map<$Value,$Value> map)
  /**Changer la valeur dans Map avec ArCreator. */
  public static <$PrimaryKey,$SecondaryKey,$Value> void changeValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArCreator<$Value,$Value> creator)

Conversion de type de valeur de carte en deux étapes

□ Convertissez le type de valeur de la carte en deux étapes pour créer une nouvelle carte MapO en deux étapes

ArMapOnMap.java


  /**Convertit le type de valeur en type spécifié dans Map.Ceux qui n'ont aucune valeur sur la carte sont ignorés. */
  public static <$PrimaryKey,$SecondaryKey,$Value,$NewValue> Map<$PrimaryKey,Map<$SecondaryKey,$NewValue>> changeValueType(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,Map<$Value,$NewValue> map) throws Exception 
  /**Convertit le type valeur en type spécifié par ArCreator.Les valeurs qui ne sont pas converties par le créateur sont ignorées*/
  public static <$PrimaryKey,$SecondaryKey,$Value,$NewValue> Map<$PrimaryKey,Map<$SecondaryKey,$NewValue>> changeValueType(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArCreator<$Value,$NewValue> creator) throws Exception

Conversion de clé de carte en deux étapes

□ Convertissez les valeurs clés.

ArMapOnMap.java


  /**Conversion de clé primaire.La clé primaire sans valeur dans keyMap reste la même. */
  public static <$PrimaryKey,$SecondaryKey,$Value> void changePrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,Map<$PrimaryKey,$PrimaryKey> keyMap) 
  /**Conversion de clé secondaire.La clé secondaire sans valeur dans keyMap reste d'origine. */
  public static <$PrimaryKey,$SecondaryKey,$Value> void changeSecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,Map<$SecondaryKey,$SecondaryKey> keyMap)

□ Créez une nouvelle carte en deux étapes avec la clé primaire et la clé secondaire échangées

ArMapOnMap.java


  /**Remplacement de la clé primaire et de la clé secondaire*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$SecondaryKey,Map<$PrimaryKey,$Value>> exchangeKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) throws InstantiationException, IllegalAccessException

Convertir la carte en deux étapes dans un autre format

□ Conversion en ListOnMap

ArMapOnMap.java


  /**Conversion en ListOnMap.La clé secondaire est supprimée.Même s'il y a des valeurs en double, elles sont définies telles quelles. */
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,List<$Value>> convertToListOnMap(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) throws InstantiationException, IllegalAccessException

□ Convertir en liste

ArMapOnMap.java


  /**Convertir en liste.Convertir uniquement la valeur.La clé primaire et la clé secondaire sont supprimées.Même s'il y a des valeurs en double, elles sont définies telles quelles. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> convertToList(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) 
  /**Convertir en liste.ArTriple contenant la clé et la valeur. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTriple<$PrimaryKey,$SecondaryKey,$Value>> convertToArTripleList(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) 
  /**Convertir en liste.Objets générés par ArCreator 3d à partir de clés et de valeurs. */
  public static <$PrimaryKey,$SecondaryKey,$Value, $NewValue> List<$NewValue> convertToArCreator3dList(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArCreator3d<$PrimaryKey,$SecondaryKey,$Value,$NewValue> creator) throws Exception

□ Conversion vers ArMatrix

ArMapOnMap.java


  /**Conversion vers ArMatrix.ArMatrix<$SecondaryKey,$PrimaryKey,$Value>Si vous souhaitez créer une clé d'échange. */
  public static <$PrimaryKey,$SecondaryKey,$Value> ArMatrix<$PrimaryKey,$SecondaryKey,$Value> convertToArMatrix(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) throws InstantiationException, IllegalAccessException

Comptage de la carte en deux étapes (comptage du nombre de données lorsque diverses conditions sont spécifiées)

□ Comptage des cartes en deux étapes

ArMapOnMap.java


  /**Nombre de clés primaires.Facile à obtenir mais à définir.*/
  public static <$PrimaryKey,$Secondarykey,$Value> int size(Map<$PrimaryKey,Map<$Secondarykey,$Value>> mapOnMap)
  /**Nombre de clés secondaires sous la clé primaire.Facile à obtenir mais à définir.*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int size(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$PrimaryKey key) 
  /**Nombre total de clés secondaires sous la clé primaire.*/
  public static <$PrimaryKey,$Secondarykey,$Value> int size(Map<$PrimaryKey,Map<$Secondarykey,$Value>> mapOnMap,ArValidator<$PrimaryKey> validator) 
  /**Nombre total de données.Les valeurs en double sont également comptées. */
  public static <$PrimaryKey,$SecondaryKey,$Value> int countAll(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) 
  /**Nombre de données sous la clé primaire spécifiée.get(key).size()Pareil que.Facile à obtenir mais à définir.*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int countByPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$PrimaryKey key) 
  /**Nombre total de données sous la clé primaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int countByPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> validator) 
  /**Nombre total de données sous la clé primaire et la clé secondaire spécifiées*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int countByKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> primaryValidator,ArValidator<$SecondaryKey> secondaryValidator) 
  /**Nombre total de données sous la clé secondaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int countSecondarykey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> secondaryValidator) 
  /**Nombre de données spécifiées*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int countValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$Value value) 
  /**Nombre de données spécifiées*/
  public static <$PrimaryKey,$SecondaryKey,$Value> int countValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> valueValidator)

Supprimer la carte en deux étapes (spécification de condition clé, spécification de condition de valeur, spécification de liste, élément vide, valeur nulle)

□ Supprimer la carte en deux étapes

ArMapOnMap.java


  /**Spécifiez la clé primaire et supprimez*/
  public static <$PrimaryKey,$SecondaryKey,$Value> void removeByPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> pValidator) throws InstantiationException, IllegalAccessException 
  /**Spécifiez la clé primaire et la clé secondaire à supprimer*/
  public static <$PrimaryKey,$SecondaryKey,$Value> void removeByKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> pValidator,ArValidator<$SecondaryKey> sValidator) 
  /**Spécifiez une clé secondaire et supprimez*/
  public static <$PrimaryKey,$SecondaryKey,$Value> void removeBySecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> sValidator)
  /**Spécifiez une valeur à supprimer*/
  public static <$PrimaryKey,$SecondaryKey,$Value> void removeByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$Value value)
  /**Spécifiez une valeur à supprimer*/
  public static <$PrimaryKey,$SecondaryKey,$Value> void removeByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> validator)
  /**Supprimer l'élément spécifié par liste*/
  public static <$PrimaryKey,$SecondaryKey,$Value> void removeByArTupleList(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,List<ArTuple<$PrimaryKey,$SecondaryKey>> list)
  /**Élément vide(Clé primaire de taille zéro ou valeur nulle, clé secondaire de valeur nulle)Supprimer. */
  public static <$PrimaryKey, $SecondaryKey, $Value> void removeEmptyAndNull(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) throws InstantiationException, IllegalAccessException

Extraction de valeurs de carte en deux étapes (spécification de condition clé, spécification de condition de valeur)

□ Extraire la valeur de la clé primaire spécifiée (autre que), spécifier la clé primaire avec ArValidator

ArMapOnMap.java


  /**Extraire la valeur de la clé primaire spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueByPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> validator)
  /**Extraire des valeurs autres que la clé primaire spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueByPrimaryKeyExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> validator)

□ Extraire la valeur de la clé secondaire spécifiée (autre que), spécifier la valeur directement pour la clé secondaire ou la spécifier avec ArValidator

ArMapOnMap.java


  /**Extraire la valeur de la clé secondaire spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueBySecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$SecondaryKey sKey) 
  /**Extraire la valeur de la clé secondaire spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueBySecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> validator)
  /**Extraire des valeurs autres que la clé secondaire spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueBySecondaryKeyExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$SecondaryKey key) 
  /**Extraire des valeurs autres que la clé secondaire spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueBySecondaryKeyExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> validator)

□ Extraire la valeur de la valeur spécifiée (autre que), spécifier la valeur avec ArValidator

ArMapOnMap.java


  /**Extraire la valeur spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> validator)
  /**Extraire des valeurs autres que la valeur spécifiée.Les valeurs en double sont également extraites. */
  public static <$PrimaryKey,$SecondaryKey,$Value> List<$Value> selectValueByValueExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> validator)

Extraction de la clé de carte en deux étapes (spécification de condition clé, spécification de condition de valeur)

□ Extraire la clé primaire

ArMapOnMap.java


  /**Extraire la clé primaire*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Set<$PrimaryKey> selectPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> pValidator) throws InstantiationException, IllegalAccessException

□ Extraire la clé primaire et la clé secondaire

ArMapOnMap.java


  /**Extraire les clés primaires et secondaires*/
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTuple<$PrimaryKey,$SecondaryKey>> selectKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$PrimaryKey pKey,$SecondaryKey sKey) 
  /**Extraire les clés primaires et secondaires*/
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTuple<$PrimaryKey,$SecondaryKey>> selectKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> pValidator,ArValidator<$SecondaryKey> sValidator)

□ Extraire la clé secondaire

ArMapOnMap.java


  /**Extraire la clé secondaire*/
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTuple<$PrimaryKey,$SecondaryKey>> selectSecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$SecondaryKey sKey) 
  /**Extraire la clé secondaire*/
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTuple<$PrimaryKey,$SecondaryKey>> selectSecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> sValidator) 
  /**Extraire la clé secondaire*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Set<$SecondaryKey> secondaryKeySet(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap)

□ Extraire la clé primaire et la clé secondaire par valeur

ArMapOnMap.java


  /**Extraire la clé par valeur*/
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTuple<$PrimaryKey,$SecondaryKey>> selectKeyByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$Value value) 
  /**Extraire la clé par valeur*/
  public static <$PrimaryKey,$SecondaryKey,$Value> List<ArTuple<$PrimaryKey,$SecondaryKey>> selectKeyByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> validator)

Extraction d'éléments de carte en deux étapes (spécification de condition clé, spécification de condition de valeur)

□ Extraire les éléments de la clé primaire spécifiée (autre que), spécifier la clé primaire avec ArValidator

ArMapOnMap.java


  /**Extraire l'élément de la clé primaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectByPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> validator) 
  /**Extraire des éléments autres que la clé primaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectByPrimaryKeyExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$PrimaryKey> validator) throws InstantiationException, IllegalAccessException

□ Extraire l'élément de la clé secondaire spécifiée (autre que), spécifier la clé secondaire directement par valeur ou par ArValidator

ArMapOnMap.java


  /**Extraire l'élément de la clé secondaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectBySecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$SecondaryKey secondaryKey)
  /**Extraire l'élément de la clé secondaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectBySecondaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> validator) 
  /**Extraire des éléments autres que la clé secondaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectBySecondaryKeyExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$SecondaryKey key) 
  /**Extraire des éléments autres que la clé secondaire spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectBySecondaryKeyExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$SecondaryKey> validator)

□ Extraire les éléments avec une valeur spécifiée (autre que), spécifier la valeur directement ou avec ArValidator

ArMapOnMap.java


  /**Extraire des éléments avec la valeur spécifiée*/
  public static <$PrimaryKey, $SecondaryKey, $Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$Value value) throws InstantiationException, IllegalAccessException 
  /**Extraire l'élément avec la valeur spécifiée avec*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectByValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> validator) throws InstantiationException, IllegalAccessException
  /**Extraire des éléments avec des valeurs autres que la valeur spécifiée*/
  public static <$PrimaryKey, $SecondaryKey, $Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectByValueExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,$Value value) 
  /**Extraire les éléments avec des valeurs autres que la valeur spécifiée avec*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> selectByValueExcept(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap,ArValidator<$Value> validator)

Jugement de valeur égale de la carte en deux étapes (il est également possible de juger avec seulement la clé)

□ Jugement de valeur égal de la carte en deux étapes

ArMapOnMap.java


  /**Déterminer si deux MapOnMaps sont égaux*/
  public static <$PrimaryKey,$SecondaryKey,$Value> boolean equals(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) 
  /**Déterminez si deux MapOnMaps sont égaux, en ignorant la valeur*/
  public static <$PrimaryKey,$SecondaryKey,$Value> boolean keyEquals(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1)

Jugement d'inclusion de carte en deux étapes (il est également possible de juger par clé uniquement)

□ Jugement d'inclusion de la carte en deux étapes

ArMapOnMap.java


  /**Détermine s'il contient la clé et la valeur MapOnMap spécifiées*/
  public static <$PrimaryKey,$SecondaryKey,$Value> boolean contains(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) 
  /**Déterminer s'il contient la clé MapOnMap spécifiée*/
  public static <$PrimaryKey,$SecondaryKey,$Value> boolean containsKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1)

Définir le fonctionnement de la carte en deux étapes (ET, OU, XOR, SAUF)

□ Définir le fonctionnement de la carte en deux étapes

ArMapOnMap.java


  /**ET de deux MapOnMap,ET avec seulement la clé.La valeur en double est la valeur de mapOnMap0*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> andKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException 
  /**ET de deux MapOnMap,ET par clé et valeur. */
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> andValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException 

  /**OU de deux MapOnMap,La valeur en double est la valeur de mapOnMap0*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> or(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException 
  /**SAUF deux MapOnMap,SAUF avec la clé primaire. */
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> exceptPrimaryKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException 
  /**SAUF deux MapOnMap,SAUF avec clé primaire et clé secondaire. */
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> exceptKey(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException 
  /**SAUF deux MapOnMap,SAUF avec clé et valeur.  */
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> exceptValue(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException 
  /**XOR de deux MapOnMap,valeur*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> xor(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap0,Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap1) throws InstantiationException, IllegalAccessException

ListOnMap (List on Map) Traitement associé (ArListOnMap) (06)

Aperçu

Génération de ListOnMap à partir de (ListOnMap, MapOnMap, Collection)

□ Cloner ListOnMap .shallow copie

ArListOnMap.java


  /**Cloner ListOnMap.copie superficielle.Identique à constructFromListOnMap*/
  public static <$Key,$Value> Map<$Key,List<$Value>> clone(Map<$Key,List<$Value>> listOnMap) throws InstantiationException, IllegalAccessException

□ Créez ListOnMap à partir de MapOnMap. La clé secondaire est perdue

ArListOnMap.java


  /**Créer ListOnMap à partir de MapOnMap.La clé secondaire est perdue. */
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,List<$Value>> constructFromMapOnMap(Map<$PrimaryKey,Map<$SecondaryKey,$Value>> mapOnMap) throws InstantiationException, IllegalAccessException

□ Créer ListOnMap à partir de la collection

ArListOnMap.java


  /**Créer ListOnMap à partir de la collection.La clé sera le champ spécifié.Si clazz est nul, ce sera HashMap.Des valeurs en double et des valeurs nulles sont également ajoutées. */
  public static <$Key,$Value> Map<$Key,List<$Value>> constructFromCollection(Collection<$Value> collection,String keyField,Class<Map> clazz) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, IllegalArgumentException, InvocationTargetException 
  /**Créer ListOnMap à partir de la collection.La clé est créée avec ArCreator.Si clazz est nul, ce sera HashMap.Des valeurs en double et des valeurs nulles sont également ajoutées. */
  public static <$Key, $Value> Map<$Key,List<$Value>> constructFromCollection(Collection<$Value> collection,ArCreator<$Value,$Key> creator,Class<Map> clazz) throws Exception

Paramètre de valeur ListOnMap

□ Ajoutez une valeur Vous pouvez également ignorer les valeurs en double ou nulles.

ArListOnMap.java


  /**Ajouter de la valeur.Vous pouvez également ignorer les valeurs en double et nulles.*/
  public static <$Key, $Value> void addValue(Map<$Key,List<$Value>> listOnMap,$Key key,$Value value,ArDuplicateAllowed dupAllowed,ArNullAllowed nullAllowed)

□ Ajoutez la clé et la valeur spécifiées dans la mappe. Vous pouvez également ignorer les valeurs en double ou nulles.

ArListOnMap.java


  /**Ajouter la clé et la valeur spécifiées dans la carte.Vous pouvez également ignorer les valeurs en double et nulles. */
  public static <$Key, $Value> void addValuesOfMap(Map<$Key,List<$Value>> listOnMap,Map<$Key,$Value> map,ArDuplicateAllowed dupAllowed,ArNullAllowed nullAllowed)

Supprimer la valeur ListOnMap

□ Supprimer la clé où la liste est vide et nulle

ArListOnMap.java


  /**Supprimer la clé lorsque la liste est vide et nulle*/
  public static <$Key, $Value> void removeEmptyAndNullKey(Map<$Key,List<$Value>> listOnMap)

□ Supprimer les valeurs en double dans la liste

ArListOnMap.java


  /**Supprimer les valeurs en double dans la liste*/
  public static <$Key,$Value> void removeDuplidatedValue(Map<$Key,List<$Value>> listOnMap)

□ Supprimer la valeur nulle dans la liste

ArListOnMap.java


  /**Supprimer la valeur nulle de List*/
  public static <$Key,$Value> void removeNullValue(Map<$Key,List<$Value>> listOnMap)

□ Supprimer la valeur spécifiée

ArListOnMap.java


  /**Supprimer la valeur spécifiée*/
  public static <$Key,$Value> void removeValue(Map<$Key,List<$Value>> listOnMap,$Value value) 
  /**Supprimer la valeur spécifiée par ArValidator*/
  public static <$Key,$Value> void removeValue(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator)

□ Supprimer la valeur spécifiée dans Collection

ArListOnMap.java


  /**Supprimer la valeur spécifiée dans Collection*/
  public static <$Key,$Value> void removeValue(Map<$Key,List<$Value>> listOnMap,Collection<$Value> values)

□ Supprimer la clé / valeur spécifiée dans la carte

ArListOnMap.java


  /**Supprimer la clé / valeur spécifiée dans la carte*/
  public static <$Key,$Value> void removeValue(Map<$Key,List<$Value>> listOnMap,Map<$Key,$Value> map)

Nombre de valeurs ListOnMap

□ Comptez le nombre de données pour la clé spécifiée par ArValidator

ArListOnMap.java


  /**Compter le nombre de données pour la clé spécifiée par ArValidator*/
  public static <$Key, $Value> int countByKey(Map<$Key,List<$Value>> listOnMap,ArValidator<$Key> validator)

□ Comptez le nombre de données avec la valeur spécifiée

ArListOnMap.java


  /**Compter le nombre de données avec la valeur spécifiée*/
  public static <$Key, $Value> int countByValue(Map<$Key,List<$Value>> listOnMap,$Value value) 
  /**Compte le nombre de données avec la valeur spécifiée par ArValidator*/
  public static <$Key, $Value> int countByValue(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator)

□ Comptez le nombre de données pour chaque clé

ArListOnMap.java


  /**Comptez le nombre de données pour chaque clé*/
  public static <$Key, $Value> Map<$Key,Integer> countMap(Map<$Key,List<$Value>> listOnMap) throws InstantiationException, IllegalAccessException

□ Comptez le nombre de données pour la valeur spécifiée de chaque clé

ArListOnMap.java


  /**Compter le nombre de données pour la valeur spécifiée pour chaque clé*/
  public static <$Key, $Value> Map<$Key,Integer> countMap(Map<$Key,List<$Value>> listOnMap,$Value value) throws InstantiationException, IllegalAccessException 
  /**Compte le nombre de données avec la valeur spécifiée par ArValidtor pour chaque clé*/
  public static <$Key, $Value> Map<$Key,Integer> countMap(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator) throws InstantiationException, IllegalAccessException

Extraction de valeurs de ListOnMap

□ Extraction des valeurs de ListOnMap

ArListOnMap.java


  /**Extraction de la valeur spécifiée par ArValidator.Les valeurs en double sont également extraites. */
  public static <$Key,$Value> List<$Value> selectValue(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator) 
  /**Extraction de valeurs autres que la valeur spécifiée*/
  public static <$Key,$Value> List<$Value> selectValueExcept(Map<$Key,List<$Value>> listOnMap,$Value value) 
  /**Extraction de valeurs autres que la valeur spécifiée par ArValidator*/
  public static <$Key,$Value> List<$Value> selectValueExcept(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator)

Extraction de clés de ListOnMap

□ Extraction de clés avec la valeur spécifiée (autre que)

ArListOnMap.java


  /**Extraction de clés avec la valeur spécifiée*/
  public static <$Key, $Value> Set<$Key> selectKey(Map<$Key,List<$Value>> listOnMap,$Value value) 
  /**Extraction de clés avec des valeurs autres que la valeur spécifiée*/
  public static <$Key, $Value> Set<$Key> selectKeyExcept(Map<$Key,List<$Value>> listOnMap,$Value value)

□ Extraction de clés avec des valeurs (autres que) spécifiées par ArValidator

ArListOnMap.java


  /**Extraction de clés avec la valeur spécifiée par ArValidator*/
  public static <$Key, $Value> Set<$Key> selectKey(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator)
  /**Extraction de clés avec des valeurs autres que celles spécifiées par ArValidator*/
  public static <$Key,$Value> Set<$Key> selectKeyExcept(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator)

Extraction d'éléments de ListOnMap

□ Extraction d'éléments avec la valeur spécifiée (autre que)

ArListOnMap.java


  /**Extraction d'éléments avec la valeur spécifiée*/
  public static <$Key,$Value> Map<$Key,List<$Value>> selectByValue(Map<$Key,List<$Value>> listOnMap,$Value value) throws InstantiationException, IllegalAccessException
  /**Extraction d'éléments avec des valeurs autres que la valeur spécifiée*/
  public static <$Key,$Value> Map<$Key,List<$Value>> selectByValueExcept(Map<$Key,List<$Value>> listOnMap,$Value value) throws InstantiationException, IllegalAccessException

□ Extraction d'éléments avec des valeurs (autres que) spécifiées par ArValidator

ArListOnMap.java


  /**Extraction d'éléments avec la valeur spécifiée par ArValidator*/
  public static <$Key,$Value> Map<$Key,List<$Value>> selectByValue(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator) throws InstantiationException, IllegalAccessException
  /**Extraction d'éléments avec des valeurs autres que la valeur spécifiée par ArValidator*/
  public static <$Key,$Value> Map<$Key,List<$Value>> selectByValueExcept(Map<$Key,List<$Value>> listOnMap,ArValidator<$Value> validator) throws InstantiationException, IllegalAccessException

□ Extraire des éléments avec des listes qui satisfont (ne satisfont pas) ArValidator

ArListOnMap.java


  /**Extraire des éléments avec une liste qui satisfait ArValidator*/
  public static <$Key,$Value> Map<$Key,List<$Value>> selectByList(Map<$Key,List<$Value>> listOnMap,ArValidator<List<$Value>> validator) throws InstantiationException, IllegalAccessException
  /**Extraire des éléments avec des listes qui ne satisfont pas ArValidator*/
  public static <$Key,$Value> Map<$Key,List<$Value>> selectByListExcept(Map<$Key,List<$Value>> listOnMap,ArValidator<List<$Value>> validator) throws InstantiationException, IllegalAccessException

Convertir la valeur ListOnMap Convertir en la valeur spécifiée par Map ou ArCreator

□ Convertir la valeur ListOnMap Convertir en la valeur spécifiée par Map ou ArCreator

ArListOnMap.java


  /**Convertir les valeurs des clés de la carte en valeurs de la carte.Convertir toutes les valeurs en double dans la liste.Les valeurs qui ne correspondent pas à Map restent inchangées*/
  public static <$Key,$Value> void convertValue(Map<$Key,List<$Value>> listOnMap,Map<$Value,$Value> map) throws Exception 
  /**Convertir des valeurs avec ArCreator.Convertir toutes les valeurs en double dans la liste.La valeur renvoyée par null dans ArCreator reste la même*/
  public static <$Key,$Value> void convertValue(Map<$Key,List<$Value>> listOnMap,ArCreator<$Value,$Value> creator) throws Exception

Conversion de type de valeur ListOnMap Convertir en type spécifié par Map ou ArCreator

□ Convertir le type de valeur ListOnMap Convertir au type spécifié par Map ou ArCreator

ArListOnMap.java


  /**Convertir les valeurs des clés de la carte en valeurs de la carte.Les valeurs qui ne correspondent pas à Map sont ignorées*/
  public static <$Key, $Value, $NewValue> Map<$Key,List<$NewValue>> convertValueType(Map<$Key,List<$Value>> listOnMap,Map<$Value,$NewValue> map) throws Exception 
  /**Convertir des valeurs avec ArCreator.Les valeurs renvoyées par ArCreator qui sont nulles sont ignorées*/
  public static <$Key, $Value, $NewValue> Map<$Key,List<$NewValue>> convertValueType(Map<$Key,List<$Value>> listOnMap,ArCreator<$Value,$NewValue> creator) throws Exception

Conversion de ListOnMap en d'autres formats

□ Conversion en carte en deux étapes. La clé secondaire est un champ spécifié

ArListOnMap.java


  /**Convertir en une carte en deux étapes.La clé secondaire est le champ spécifié*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> convertToMapOnMap(Map<$PrimaryKey,List<$Value>> listOnMap,String sKey,Class secondaryMapClass) throws Exception

□ Conversion en carte en deux étapes. La clé secondaire est $ Value convertie par ArCreator

ArListOnMap.java


  /**Convertir en une carte en deux étapes.La clé secondaire est$Valeur convertie avec ArCreator*/
  public static <$PrimaryKey,$SecondaryKey,$Value> Map<$PrimaryKey,Map<$SecondaryKey,$Value>> convertToMapOnMap(Map<$PrimaryKey,List<$Value>> listOnMap,ArCreator<$Value,$SecondaryKey> creator,Class secondaryMapClass) throws Exception

□ Convertir en liste. Les clés sont supprimées

ArListOnMap.java


  /** List<$Value>Convertir en.La clé est jetée*/
  public static <$Key,$Value> List<$Value> convertToList(Map<$Key,List<$Value>> listOnMap)

□ Convertissez les clés et les valeurs avec ArCreator2d pour créer une liste

ArListOnMap.java


  /**Clé($Key)Et valeur($Value)Avec ArCreator 2d$Convertir en NewValue et en liste<$NewValue>Créer.  */
  public static <$Key,$Value,$NewValue> List<$NewValue> convertToListByArCreator2d(Map<$Key,List<$Value>> listOnMap,ArCreator2d<$Key,$Value,$NewValue> creator) throws Exception

□ Créez une liste d'ArTuple de clés et de valeurs

ArListOnMap.java


  /** List<ArTuple<$Key,$Value>>Convertir en*/
  public static <$Key, $Value> List<ArTuple<$Key,$Value>> convertToListOfArTuple(Map<$Key,List<$Value>> listOnMap)

□ Convertir la liste avec ArCreator

ArListOnMap.java


  /**Convertir la liste avec ArCreator*/
  public static <$Key,$Value,$NewValue> Map<$Key,$NewValue> convertListByArCreator(Map<$Key,List<$Value>> listOnMap,ArCreator<List<$Value>,$NewValue> creator) throws Exception

Définir le fonctionnement de deux ListOnMap

□ Réglez le fonctionnement de deux ListOnMap

ArListOnMap.java


  /**ET deux ListOnMaps.Non seulement la clé mais aussi les éléments de la liste sont ET.La liste résultante n'a pas de valeurs en double. */
  public static <$Key,$Value> Map<$Key,List<$Value>> and(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1) throws InstantiationException, IllegalAccessException 
  /**OU deux ListOnMaps.La liste résultante peut contenir des valeurs en double*/
  public static <$Key,$Value> Map<$Key,List<$Value>> or(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1) throws InstantiationException, IllegalAccessException 
  /**XOR deux ListOnMaps avec une clé*/
  public static <$Key,$Value> Map<$Key,List<$Value>> xorKey(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1) throws InstantiationException, IllegalAccessException 
  /**XOR deux ListOnMaps.XOR avec clé.Liste XOR pour la même clé*/
  public static <$Key,$Value> Map<$Key,List<$Value>> xorList(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1) throws InstantiationException, IllegalAccessException 
  /**SAUF deux ListOnMaps avec une clé*/
  public static <$Key,$Value> Map<$Key,List<$Value>> exceptKey(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1) throws InstantiationException, IllegalAccessException 
  /**SAUF deux ListOnMaps.SAUF avec la clé.SAUF avec la même clé dans la liste*/
  public static <$Key,$Value> Map<$Key,List<$Value>> exceptList(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1) throws InstantiationException, IllegalAccessException

Jugement de valeur égale de deux ListOnMap

□ Jugement de valeur égal de deux ListOnMap

ArListOnMap.java


  /**Jugement de valeur égale de deux ListOnMap.Ignorer les valeurs en double, ignorer l'ordre et ignorer les valeurs nulles peut être spécifié pour le jugement de liste.*/
  public static <$Key,$Value> boolean equals(Map<$Key,List<$Value>> listOnMap0,Map<$Key,List<$Value>> listOnMap1,ArSeqIgnore seqIgnore,ArNullIgnore nullIgnore,ArDuplicateIgnore dupIgnore) 
  /**Obtient la clé contenant la liste spécifiée.Ignorer les valeurs en double, ignorer l'ordre et ignorer les valeurs nulles peut être spécifié pour le jugement de liste.*/
  public static <$Key, $Value> Set<$Key> selectKeyByList(Map<$Key,List<$Value>> listOnMap,List<$Value> list,ArSeqIgnore seqIgnore,ArNullIgnore nullIgnore,ArDuplicateIgnore dupIgnore)

Classe de construction de structure de données (artère d'origine) (01)

Carte ArBiMap-bidirectionnelle

Les termes «clé» et «valeur» sont utilisés par commodité, mais il n'y a pas de distinction fonctionnelle entre les deux.

Aperçu

Génération ArBiMap

□ Constructeur

ArBiMap.java


  /**constructeur.  */
  public ArBiMap()

□ Générer à partir d'ArBiMap

ArBiMap.java


  /**constructeur.Créer à partir d'ArBiMap*/
  public ArBiMap(ArBiMap<T0,T1> biMap)

□ Générer à partir de deux séquences

ArBiMap.java


  /**constructeur.Créer un ArBiMap à partir de deux tableaux. */
  public ArBiMap(T0[] keys,T1[] values)

□ Générer à partir de la carte

ArBiMap.java


  /**constructeur.Générer ArBiMap à partir de la carte.*/
  public static <T0,T1> ArBiMap<T0,T1> constructFromMap(Map<T0,T1> map)

□ Générer à partir d'un tableau à deux dimensions

ArBiMap.java


  /**constructeur.Générer à partir d'un tableau à deux dimensions.L'index de clé est 0, l'indice de valeur est 1. */
  public <T> ArBiMap(T[][] keysAndValues) 
  /**constructeur.Créer un ArBiMap en spécifiant des index de clé et de valeur à partir d'un tableau à deux dimensions.*/
  public ArBiMap(T0[][] keysAndValues,int keyIndex,int valueIndex)

□ Générer à partir de Csv balisés

ArBiMap.java


  /**constructeur.Créer à partir de Csv balisé. */
  public ArBiMap(String str)

Paramètres ArBiMap / acquisition / suppression

□ Touche ⇒ Définir la valeur.

ArBiMap.java


  /**Définir la clé ⇒ Valeur.   */
  public void putKeyValue(T0 key,T1 value)

□ Obtenir la valeur de la clé

ArBiMap.java


  /**Obtenir la valeur de la clé.  */
  public T1 getByKey(T0 key)

□ Récupérez la clé de Value

ArBiMap.java


  /**Obtenez la clé de Value.  */
  public T0 getByValue(T1 value)

□ Obtenez une liste de clés

ArBiMap.java


  /**Obtenez une liste de clés. */
  public Set<T0> keySet()

□ Obtenez une liste de valeurs.

ArBiMap.java


  /**Obtenez une liste de valeurs. */
  public Set<T1> valueSet()

□ Effacer en fonction de la clé La valeur correspondante est renvoyée.

ArBiMap.java


  /**Supprimer en fonction de la clé.La valeur correspondante est renvoyée.*/
  public T1 removeByKey(T0 key)

□ Supprimer en fonction de la valeur La clé correspondante est renvoyée.

ArBiMap.java


  /**Supprimer en fonction de la valeur.La clé correspondante est retournée. */
  public T0 removeByValue(T1 value)

□ Clair.

ArBiMap.java


  /**clair. */
  public void clear()

Confirmation de l'existence de la clé et de la valeur ArBiMap

□ Renvoie le nombre de données.

ArBiMap.java


  /**Renvoie le nombre de données. */
  public int size()

□ Confirmation de l'existence de la clé.

ArBiMap.java


  /**Confirmation de l'existence de la clé. */
  public boolean containsKey(T0 key) 
  /**Confirmation de l'existence de la clé*/
  public boolean containsKey(ArValidator<T0> validator)

□ Confirmation de l'existence de la valeur.

ArBiMap.java


  /**Confirmation de valeur. */
  public boolean containsValue(T1 value) 
  /**Confirmation de valeur*/
  public boolean containsValue(ArValidator<T1> validator)

Extraction d'éléments ArBiMap

□ Extraire les clés qui satisfont (ne remplissent pas) les conditions

ArBiMap.java


  /**Obtenez une liste de clés qui satisfont un validateur*/
  public Set<T0> selectKey(ArValidator<T0> validator) throws InstantiationException, IllegalAccessException 
  /**Obtenez une liste de clés qui ne satisfont pas le validateur*/
  public Set<T0> selectKeyExcept(ArValidator<T0> validator) throws InstantiationException, IllegalAccessException

□ Extraire les valeurs qui satisfont (ne satisfont pas) aux conditions

ArBiMap.java


  /**Obtenez une liste de valeurs qui satisfont le validateur*/
  public Set<T1> selectValue(ArValidator<T1> validator) throws InstantiationException, IllegalAccessException 
  /**Obtenez une liste de valeurs qui ne satisfont pas le validateur*/
  public Set<T1> selectValueExcept(ArValidator<T1> validator) throws InstantiationException, IllegalAccessException

□ Extraire des éléments avec des clés qui satisfont (ne pas) condition

ArBiMap.java


  /**Créez un nouvel ArBiMap en sélectionnant la clé avec le validateur.  */
  public ArBiMap<T0,T1> selectByKey(ArValidator<T0> validator) 
  /**Créez un nouvel ArBiMap en sélectionnant une clé qui ne correspond pas au validateur.  */
  public ArBiMap<T0,T1> selectByKeyExcept(ArValidator<T0> validator)

□ Extraire les éléments dont les valeurs satisfont (ne satisfont pas) les conditions

ArBiMap.java


  /**Créer un nouvel ArBiMap en sélectionnant une valeur avec le validateur.  */
  public ArBiMap<T0,T1> selectByValue(ArValidator<T1> validator) 
  /**Créez un nouvel ArBiMap en sélectionnant une valeur qui ne correspond pas au validateur.  */
  public ArBiMap<T0,T1> selectByValueExcept(ArValidator<T1> validator)

Conversion vers d'autres structures d'ArBiMap

□ Convertir en carte

ArBiMap.java


  /**Convertir en carte.Clé → valeur*/
  public Map<T0,T1> toMap() 
  /**Convertir en carte.Valeur → clé*/
  public Map<T0,T1> toReverseMap()

□ Convertir la clé en une autre clé affichée sur la carte

ArBiMap.java


  /**Convertir une clé en une autre clé affichée dans la carte*/
  public void changeKey(Map<T0,T0> map)

□ Convertir une valeur en une autre valeur affichée dans la carte

ArBiMap.java


  /**Convertir une valeur en une autre valeur affichée dans la carte*/
  public void changeValue(Map<T1,T1> map)

Fonctionnement logique de deux ArBiMap

□ AND

ArBiMap.java


  /**ET avec clé pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> andKey(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)
  /**ET par valeur pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> andValue(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)

□ OR

ArBiMap.java


  /**OU avec clé pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> orKey(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)
  /**OU par valeur pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> orValue(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)

□ XOR

ArBiMap.java


  /**XOR avec clé pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> xorKey(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)
  /**XOR par valeur pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> xorValue(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)

□ EXCEPT

ArBiMap.java


  /**SAUF avec clé pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> exceptKey(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)
  /**SAUF par valeur pour créer un nouvel ArBiMap*/
  public static ArBiMap<T0,T1> exceptValue(ArBiMap<T0,T1> biMap0,ArBiMap<T1,T1> biMap1)

ArMatrix - Carte à deux dimensions

Aperçu

Génération ArMatrix

□ Constructeur

ArMatrix.java


  /**constructeur. */
  public ArMatrix()
  /**constructeur*/
  public ArMatrix(ArMatrix<T0,T1,T2> mat)

□ Générer ArMatrix à partir d'une carte en deux étapes

ArMatrix.java


  /**Générer ArMatrix à partir d'une carte en deux étapes*/
  public ArMatrix(ArMatrix<T0,T1,T2> mat)

□ Générez ArMatrix en spécifiant les champs clés de Collection

ArMatrix.java


  /**constructeur.Généré en spécifiant le champ clé de Collection*/
  public ArMatrix(Collection<T2> collection,String key0Field,String key1Field) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InvocationTargetException

□ Générez ArMatrix en spécifiant ArCreator à partir de la collection

ArMatrix.java


  /**constructeur.Généré en spécifiant ArCreator à partir de la collection*/
  public ArMatrix(Collection<T2> collection,ArCreator<T2,T0> key0Creator,ArCreator<T2,T1> key1Creator) throws Exception {

Définir, obtenir et supprimer des valeurs ArMatrix

□ Définir le mode de mise à jour. En fonction de cette valeur, put est ignoré

ArMatrix.java


  /**
   *Définir le mode de mise à jour.En fonction de cette valeur, put sera ignoré.La valeur initiale est TOUJOURS.
   *  mode : ArUpdateMode.TOUJOURS Toujours ajouter / mettre à jour
   *  mode : ArUpdateMode.PAS Toujours ajouter / mettre à jour
   *  mode : ArUpdateMode.IF_Mettez à jour la clé EXISTS si elle existe
   *  mode : ArUpdateMode.IF_NOT_Ajoutez la clé EXISTS si elle n'existe pas
   */
  public void setUpdateMode(ArUpdateMode mode)

□ Définissez la valeur. Obtenez la valeur.

ArMatrix.java


  /**Définissez la valeur. */
  public void put(T0 key0,T1 key1,T2 value) 
  /**Obtenez la valeur. */
  public T2 get(T0 key0,T1 key1)

□ Obtenir la carte avec la touche 0.

ArMatrix.java


  /**Obtenir la carte avec la clé 0. */
  public Map<T1,T2> getByKey0(T0 key0)

□ Obtenir la carte avec la touche 1.

ArMatrix.java


  /**Obtenir la carte avec la clé 1. */
  public Map<T0,T2> getByKey1(T1 key1)

□ Obtenez la liste de la clé 0. Obtenez la liste de la clé 1.

ArMatrix.java


  /**Obtenir une liste de clé 0. */
  public Set<T0> key0Set() 
  /**Obtenez une liste de la clé 1. */
  public Set<T1> key1Set()

□ Obtenez une liste de valeurs.

ArMatrix.java


  /**Obtenez une liste de valeurs.S'il y a la même valeur, elle sera acquise plus d'une fois..la valeur nulle n'est pas récupérée. */
  public List<T2> values()

□ Supprimer la valeur.

ArMatrix.java


  /**Supprimer la valeur.. */
  public T2 remove(T0 key0,T1 key1)

□ Supprimer l'élément avec key0 ..

ArMatrix.java


  /**Supprimer l'élément avec key0.. */
  public void removeByKey0(T0 key0)

□ Supprimer l'élément avec key1.

ArMatrix.java


  /**Supprimer l'élément avec key1.. */
  public void removeByKey1(T1 key1)

□ Effacez toutes les données.

ArMatrix.java


  /**Effacer toutes les données. */
  public void clear()

Confirmation de l'existence d'ArMatrix

□ Confirmation de l'existence de la clé

ArMatrix.java


  /**Confirmation de l'existence de la clé. */
  public boolean containsKey(T0 key0,T1 key1)

□ Confirmation de l'existence de l'élément

ArMatrix.java


  /**Confirmation de l'existence de l'élément*/
  public boolean containsElement(T0 key0,T1 key1,T2 value)

□ Confirmation de valeur

ArMatrix.java


  /**Confirmation de valeur*/
  public boolean containsValue(T2 value) 
  /**Confirmation de valeur*/
  public boolean containsValue(ArValidator<T2> validator)

□ Comptez le nombre d'éléments

ArMatrix.java


  /**Renvoie le nombre total de données. */
  public int totalSize() 
  /**Comptez le nombre d'éléments qui correspondent à la valeur. */
  public int countValue(T2 value) 
  /**Comptez le nombre d'éléments qui correspondent à la valeur. */
  public int countValue(ArValidator<T2> validator)

Extraction d'éléments ArMatrix

□ Extraire les éléments qui correspondent (ne correspondent pas) clé 0

ArMatrix.java


  /**Créez un nouvel ArMatrix en sélectionnant Key0 qui correspond au validateur. */
  public ArMatrix<T0,T1,T2> selectByKey0(ArValidator<T0> validator)  
  /**Créez un nouvel ArMatrix en sélectionnant Key0 qui ne correspond pas au validateur. */
  public ArMatrix<T0,T1,T2> selectByKey0Except(ArValidator<T0> validator)

□ Extraire les éléments qui correspondent (ne correspondent pas) à la clé 1

ArMatrix.java


  /**Créez un nouvel ArMatrix en sélectionnant la Key1 qui correspond au validateur.*/
  public ArMatrix<T0,T1,T2> selectByKey1(ArValidator<T1> validator) 
  /**Créez un nouvel ArMatrix en sélectionnant Key1 qui ne correspond pas au validateur. */
  public ArMatrix<T0,T1,T2> selectByKey1Except(ArValidator<T1> validator)

□ Extraction des éléments qui correspondent (ne correspondent pas) à la valeur

ArMatrix.java


  /**Sélectionnez par valeur pour créer un nouvel ArMatrix. */
  public ArMatrix<T0,T1,T2> selectByValue(T2 element) 
  /**Créez un nouvel ArMatrix en sélectionnant une valeur qui correspond au validateur. */
  public ArMatrix<T0,T1,T2> selectByValue(ArValidator<T2> validator) 
  /**Créez un nouvel ArMatrix en sélectionnant une valeur qui ne correspond pas au validateur. */
  public ArMatrix<T0,T1,T2> selectByValueExcept(ArValidator<T2> validator)

Conversion ArMatrix

□ Swap key0 et key1

ArMatrix.java


  /**Swap key0 et key1*/
  public ArMatrix<T1,T0,T2> exchangeKey()

□ Conversion par lots des valeurs

ArMatrix.java


  /**Remplacez la valeur par la valeur affichée dans valueMap.Les autres valeurs restent inchangées*/
  public void changeValue(Map<T2,T2> valueMap) 
  /**Créez un ArMatrix avec des valeurs converties en objets T3 avec Creator. */
  public <T3> ArMatrix<T0,T1,T3> convert(ArCreator<T2,T3> creator) throws Exception

□ Convertissez en MapOnMap.

ArMatrix.java


  /**Convertir en MapOnMap. */
  public Map<T0,Map<T1,T2>> toMapOnMap() throws InstantiationException, IllegalAccessException

Fonctionnement logique de deux ArMatrix

□ Fonctionnement ET avec d'autres ArMatrix

ArMatrix.java

□ Fonctionnement OU avec un autre ArMatrix

ArMatrix.java

□ Fonctionnement XOR avec d'autres ArMatrix

ArMatrix.java

□ SAUF fonctionnement avec un autre ArMatrix

ArMatrix.java

Interface importante (02)

Il existe de nombreuses interfaces, mais en voici quelques-unes: Celles-ci jouent un rôle important dans la programmation utilisant cette bibliothèque, mais elles sont également utilisées considérablement à l'intérieur de cette bibliothèque.

ArValidator --Un argument ⇒ vrai / faux (02_00)

Définition

ArValidator.java


/**Interface qui détermine la validité de l'objet spécifié. */
public interface ArValidator<T> {
  /**
   *Déterminez l'objet spécifié.
   *  @valeur de paramètre Objet cible de jugement.
   */
  public boolean check(T value)

Exemple d'utilisation

ArValidator2d --Deux arguments ⇒ vrai / faux (02_01)

Définition

ArValidator2d.java


/**Une interface qui vérifie la validité sur la base de deux valeurs*/
public interface ArValidator2d<$arg0,$arg1> {
  /**Vérifiez la valeur*/
  public boolean check($arg0 arg0,$arg1 arg1)
}

Exemple d'utilisation

ArCreator-Convertit un argument en un autre (02_02)

Définition

ArCreator.java


/**Interface qui crée un autre objet à partir de l'objet spécifié. */
public interface ArCreator<T0,T1> {
  /**Créer un objet de classe T1 à partir d'obj.Je ne sais pas ce que fait l'implémentation, alors lancez une exception. */
  public T1 convert(T0 obj) throws Exception;
}

Exemple d'utilisation

ArCreator2d-Convertir deux arguments en valeurs différentes (02_03)

Définition

ArCreator2d.java


/**Interface qui génère une autre valeur basée sur deux valeurs*/
public interface ArCreator2d<$Arg0,$Arg1,$Value> {
  /**De arg0 et arg1$Créer un objet de classe de valeur.Je ne sais pas ce que fait l'implémentation, alors lancez une exception. */
  public $Value convert($Arg0 arg0,$Arg1 arg1) throws Exception;
}

Exemple d'utilisation

ArCreator3d-Convertir trois arguments en valeurs différentes (02_04)

Définition

ArCreator3d.java


/**Interface qui génère une autre valeur basée sur trois valeurs*/
public interface ArCreator3d<$Arg0,$Arg1,$Arg2,$Value> {
  /**De arg0 et arg1$Créer un objet de classe de valeur.Je ne sais pas ce que fait l'implémentation, alors lancez une exception. */
  public $Value convert($Arg0 arg0,$Arg1 arg1,$Arg2 arg2) throws Exception;
}

Exemple d'utilisation

Classe de conservation des données (03)

ArTuple-Deux ensembles de données (03_00)

Aperçu

Une classe qui représente deux ensembles de données. En dehors de cela, vous pouvez stocker un objet arbitraire.

Données ArTriple-Triple (03_01)

Aperçu

Une classe qui représente un triplet de données. En dehors de cela, vous pouvez stocker un objet arbitraire.

CSV (ArCsv) - Chaîne séparée par des virgules (03_02)

Aperçu

Une classe qui représente une chaîne séparée par des virgules. Le délimiteur peut être personnalisé.

TaggedCSV (ArTaggedCsv) - Chaîne double séparée par des virgules (03_03)

Aperçu

Une classe qui exprime les chaînes de caractères suivantes. Le délimiteur peut être personnalisé. name=suzuki,address=tokyou,age=30

Traitement des chaînes (04)

Traitement des chaînes de caractères

□ Mettez la première lettre en majuscule.

ArStr.java


  /**Mettre la première lettre en majuscule. */
  public static String topUpper(String str)

□ Réduisez la première lettre.

ArStr.java


  /**Rendre la première lettre plus basse. */
  public static String topLower(String str)

□ Convertir en casse de titre (première majuscule, dernière minuscule)

ArStr.java


  /**Cas du titre(Première majuscule, dernière minuscule)Convertir en*/
  public static String toTitleCase(String str)

□ Mettez la chaîne entre parenthèses.

ArStr.java


  /**
   *Mettez la chaîne entre parenthèses.la taille du support est 2.
   *le support est()Ou[], [] Etc..Cette méthode ne vérifie pas qu'elle est entre parenthèses.
   */
  public static String wrapBracket(String str,String[] bracket)

□ Extrayez la chaîne de caractères entre parenthèses.

ArStr.java


  /**
   *Extraire la chaîne de caractères entre parenthèses.
   *Si les deux extrémités de str ne correspondent pas à la parenthèse, renvoyez la chaîne d'origine.
   *  @param bracket String[2],Représente les parenthèses aux deux extrémités.Remarque, je n'ai pas vérifié s'il s'agit de parenthèses.
   */
  public static String unwrapBracket(String str,String[] bracket) 
  /**CharDef aux deux extrémités.BRACKET_S'il correspond à l'une des listes, supprimez les parenthèses aux deux extrémités et retournez. */
  public static String unwrapBracket(String str)

□ Remplacement de la chaîne de caractères

ArStr.java


  /**
   *Remplacez oldStr dans str par newStr.Tout remplacer s'il y a plusieurs oldStr.
   *Remarque, intention de création.Étant donné que le symbole est une expression régulière dans replaceAll of String, je souhaite le remplacer par quelque chose qui n'est pas une expression régulière..
   */
  public static String replaceAll(String str,String oldStr,String newStr)

Nombre de caractères et d'octets

□ Calculez le nombre d'octets de la chaîne.

ArStr.java


  /**Calculer le nombre d'octets dans une chaîne. */
  public static long byteLength(String str,String charset) throws UnsupportedEncodingException

□ Supprimez la fin de la chaîne de caractères pour qu'elle contienne le nombre d'octets spécifié.

ArStr.java


  /**Supprimez la fin de la chaîne pour qu'elle contienne le nombre d'octets spécifié. */
  public static String deleteLast(String str,String charSet,long len) throws UnsupportedEncodingException

□ Ajoutez de l'espace au nombre d'octets spécifié.

ArStr.java


  public static String append(String str,String charSet,long len) throws UnsupportedEncodingException

□ Ajoutez des caractères après pour lui donner la longueur spécifiée.

ArStr.java


  /**
   *Lettres ultérieures(val)À la longueur spécifiée.
   *La longueur de val est 1(Sinon, ne convertissez pas).
   */
  public static String append(String str,int len,String val)

□ Insérez un caractère devant pour lui donner la longueur spécifiée.

ArStr.java


  /**
   *Lettre avant(val)À la longueur spécifiée.
   *La longueur de val est 1(Sinon, ne convertissez pas).
   */
  public static String insert(String str,int len,String val)

□ Répétez la chaîne de caractères le nombre de fois spécifié.

ArStr.java


  /**Répétez la chaîne un certain nombre de fois. */
  public static String repeat(String str,Integer cnt)

Jugement et conversion liés à l'espace

□ Convertissez null en une chaîne vide ("").

ArStr.java


  /**
   *null en chaîne vide("")Convertir en.
   *S'il n'est pas nul, renvoie la chaîne d'origine.
   */
  public static String nullToEmpty(String str)

□ Déterminez s'il est nul ou une chaîne vide ("").

ArStr.java


  /**chaîne nulle ou vide("")Déterminez si. */
  public static boolean isNullOrEmpty(String s)

□ Assurez-vous qu'il ne s'agit ni d'une chaîne nulle ni d'une chaîne vide ("").

ArStr.java


  /**Chaîne vide, non nulle("")Assurez-vous que ce n'est pas. */
  public static boolean isNotNullOrEmpty(String s)

□ Déterminez s'il s'agit d'un espace ou d'une tabulation.

ArStr.java


  /**Déterminez s'il s'agit d'un espace ou d'une tabulation. */
  public static Boolean isSpace(String s)

□ Déterminez s'il s'agit d'un espace, d'une tabulation ou d'un espace pleine largeur.

ArStr.java


  /**Déterminez s'il s'agit d'un espace, d'une tabulation ou d'un espace pleine largeur. */
  public static Boolean isJSpace(String s)

□ Déterminez si le début est un espace, une tabulation ou un espace pleine largeur.

ArStr.java


  /**Déterminez si le début est un espace, une tabulation ou un espace pleine largeur. */
  public static boolean startsWithJSpace(String s)

□ Déterminez si le dernier est un espace, une tabulation ou un espace pleine largeur.

ArStr.java


  /**Déterminez si la fin est un espace, une tabulation ou un espace pleine largeur. */
  public static Boolean endsWithJSpace(String s)

□ Pleine largeur ⇒ conversion d'espace demi-largeur.

ArStr.java


  /**Pleine largeur ⇒ conversion d'espace demi-largeur. */
  public static String jSpaceToESpace(String str)

□ Demi-largeur ⇒ conversion d'espace pleine largeur.

ArStr.java


  /**Demi-largeur ⇒ conversion d'espace pleine largeur. */
  public static String eSpaceToJSpace(String str)

□ Supprimez le précédent (espace, tabulation).

ArStr.java


  /**Avant(Espaces, onglets)Supprimer. */
  public static String trimLeadingESace(String str)

□ Supprimez le recto (espace, tabulation, espace pleine largeur).

ArStr.java


  /**Avant(Espaces, tabulations, espaces pleine largeur)Supprimer. */
  public static String trimLeadingJSace(String str)

□ Supprimer après (espace, tabulation).

ArStr.java


  /**arrière(Espaces, onglets)Supprimer. */
  public static String trimTrailingESace(String str)

□ Supprimer après (espace, tabulation, espace pleine largeur).

ArStr.java


  /**arrière(Espaces, tabulations, espaces pleine largeur)Supprimer. */
  public static String trimTrailingJSace(String str) {

□ Supprimez l'espace avant et après, l'onglet et l'espace pleine largeur.

ArStr.java


  /**Supprimer les espaces avant et arrière, les tabulations et les espaces pleine largeur.String.trim()Extension de. */
  public static String trim(String str) {

□ Combinez plusieurs espaces et tabulations en un seul.

ArStr.java


  /**
   *Combinez plusieurs espaces et onglets en un seul.
   * @param str Chaîne de caractères à traiter
   * @param collect méthode de traitement, SPACE_ONLY:Seul l'espace, TAB_ONLY:Tab seulement, CHAQUE:Espaces et tabulations séparés, LES DEUX:Traiter les espaces et les onglets ensemble(Le résultat est l'espace)
   * @return Chaîne de résultat du traitement
   */
  public static String collectSpaceTab(String str,ArSpaceTabCollect collect)

Justifié à droite, justifié à gauche, centrage

□ Justifié à gauche, justifié à droite, centré

ArStr.java


  /**
   *Justifier à gauche.
   *la largeur est la largeur finie(nombre de mots).
   *Lorsque la largeur n'est pas suffisante, la coupe est ArCut.Si OUI, réduire à la largeur, ArCut.Si NON, retournez str tel quel.
   */
  public static String lefting(String str,int width,ArCut cut) 
  /**
   *Justifier à droite.
   *la largeur est la largeur finie(nombre de mots).
   *Lorsque la largeur n'est pas suffisante, la coupe est ArCut.Si OUI, réduire à la largeur, ArCut.Si NON, retournez str tel quel.
   */
  public static String righting(String str,int width,ArCut cut) 
  /**
   *Centrage.
   *la largeur est la largeur finie(nombre de mots).
   *Lorsque la largeur n'est pas suffisante, la coupe est ArCut.Si OUI, réduire à la largeur, ArCut.Si NON, retournez str tel quel.
   */
  public static String centering(String str,int width,ArCut cut)

Guillemets

□ Ajouter des citations, supprimer les guillemets

ArStr.java


  /**
   *Citations aux deux extrémités(")Supprimer.
   *S'il n'y a pas de devis, renvoyez-le tel quel.
   */
  public static String removeQuote(String str) 
  /**
   *Mettez des guillemets aux deux extrémités.
   *Échappez-vous s'il y a une citation à l'intérieur.
   */
  public static String quote(String str)

Vérification du type de caractère

□ Vérification du type de caractère

ArStr.java


  /**Alphabet. */
  public static boolean is_Alpha(String str) 
  /**Première lettre. */
  public static boolean is_TopAlpha(String str) 
  /**Alphabet. */
  public static boolean is_AlphaNumeric(String str) 
  /**Première lettre, puis alphanumérique. */
  public static boolean is_TopAlpha_AlphaNumeric(String str) 
  /**Grand alphabet. */
  public static boolean is_UAlpha(String str) 
  /**Première grande lettre. */
  public static boolean is_TopUAlpha(String str) 
  /**Première grande lettre, deuxième lettre. */
  public static boolean is_TopUAlpha_Alpha(String str) 
  /**Première grande lettre, dernier alphanumérique. */
  public static boolean is_TopUAlpha_AlphaNumeric(String str) 
  /**Premier grand alphabet, deuxième gros caractères alphanumériques. */
  public static boolean is_TopUAlpha_UAlphaNumeric(String str) 
  /**Petit alphabet. */
  public static boolean is_LAlpha(String str) 
  /**Première petite lettre. */
  public static boolean is_TopLAlpha(String str) 
  /**Première lettre minuscule, deuxième lettre. */
  public static boolean is_TopLAlpha_Alpha(String str) 
  /**Premières petites lettres, derniers caractères alphanumériques. */
  public static boolean is_TopLAlpha_AlphaNumeric(String str) 
  /**Premier petit alphabet, derniers petits caractères alphanumériques. */
  public static boolean is_TopLAlpha_LAlphaNumeric(String str) 
  /**identifiant java. */ //Chiffres, lettres,_ $  //Peut être au début sauf pour les nombres
  public static boolean is_JavaIdentifier(String str) 
  /**Nombres.Remarque, il est préférable d'analyser avec Integer. */
  public static boolean is_Numeric(String str) 
  /**Les nombres autres que le premier 0, le nombre après. */
  public static boolean is_TopNonZeroNumeric_Numeric(String str) 
  /**Nombres(Tous les trois chiffres). */
  public static boolean is_CommaNumeric(String str) 
  /**Code postal. */
  public static boolean is_PostalCode(String str) 
  /**Numéro de téléphone portable. */
  public static boolean is_Cellular(String str)

Remplacement de la chaîne de caractères

ArStr.java


  /**Dans la chaîne${xxxx}Mettre en forme les noms des variables[xxxx]Correspondant aux vals[]Remplacer par la valeur de. */
  public static String replaceSymbols(String str,String[] symbols,String[] vals) 
  /**Dans la chaîne${xxxx}Remplacer les variables de format par les valeurs de clé Map xxxx. */
  public static String replaceSymbols(String str,Map<String,String> map) 
  /** ${xxx}Extraire le format xxx.Même chose ou plusieurs fois mais une seule fois. */
  public static Set<String> getVariableSymbols(String str)

Traitement des chaînes de caractères représentant la date et l'heure

ArStr.java


  /**
   *  ${DATExxxx}Avec la date et l'heure actuelles.
   *xxxx est un format géré par SimpleDateFormat.
   */
  public static String replaceByDate(String str) 
  /**
   *  ${DATExxxx}Remplacez par la date et l'heure, etc..
   *xxxx est un format géré par SimpleDateFormat.
   */
  public static String replaceByDate(String str,java.util.Date date) 
  /**
   *  ${DATExxxx}Remplacez par la date et l'heure, etc..
   *xxxx est un format géré par SimpleDateFormat.
   */
  public static String replaceByDate(String str,java.util.Calendar cal) 
  /**
   *  ${DATExxxx}Remplacez par la date et l'heure, etc..
   *xxxx est un format géré par SimpleDateFormat.
   */
  public static String replaceByDate(String str,long time)

Traitement des chaînes de caractères représentant des nombres

□ Traitement des chaînes de caractères représentant des nombres

ArStr.java


  /**
   *Caractère avant str(val)À la longueur spécifiée.
   *Renvoie null si nul.
   *La longueur de val est 1(Ne convertissez pas).
   *Remarque, NumStr a la même méthode, qui appelle cette méthode.
   */
  public static String insertTop(String str,int len,String val) 
  /**Insérez une virgule tous les trois chiffres. */
  public static String insertComma(String val) 
  /**Supprimer le zéro précédent.Identique à deleteLeadingZero. */
  public static String removeLeadingZero(String str)

Divisez la chaîne en un tableau, List, Set

□ Divisez la chaîne de caractères en un tableau, List, Set

ArStr.java


  /**virgule(Tel)Divisez avec et créez un tableau.(String.Redéfinir la division). */
  public static String[] splitToArray(String str,char sep) 
  /**virgule(Tel)Divisez et faites une liste. */
  public static List<String> splitToList(String str,char sep) 
  /**Divisez par une virgule, etc. pour créer un ensemble.(Puisqu'il s'agit d'un ensemble, il sera agrégé si les éléments sont dupliqués). */
  public static Set<String> splitToSet(String str,char sep) throws InstantiationException, IllegalAccessException

Concaténation de chaînes

□ Combiner des chaînes

ArStr.java


  /**Combinez str avec sep pour compter les temps. */
  public static String join(char sep,String str,int count) 
  /**Combiner la liste des chaînes avec sep. */
  public static String join(char sep,List<String> values) 
  /**Combinez les arguments variables de String1 avec sep. */
  public static String join(char sep,String... values) 
  /**Combinez Set of String1 avec sep. */
  public static String join(char sep,Set<String> values)

Comparaison de chaînes ignorant les sauts de ligne, les majuscules / minuscules, les tabulations d'espace

ArStr.java


  /**
   *Comparer des chaînes.
   * @param arCase Ignorer les majuscules et les minuscules
   * @param arSpace espace/Ignorer les onglets.Notez que si OUI, comparez plusieurs espaces et tabulations comme un seul espace..
   * @param arBreak Ignorer les sauts de ligne.
   */
  public static int compare(String str0,String str1,ArCase arCase,ArSpaceIgnore arSpace,ArLineBreakIgnore arBreak)

Traitement des symboles Java

□ Traitement des symboles Java

ArStr.java


  /**Convertir les noms de champ en noms de setter. */
  public static String setterName(String field) 
  /**Convertir les noms de champs en noms de lecture. */
  public static String getterName(String field) 
  /**
   *  _Pour supprimer et convertir en CamelCase.
   *Remarque, utilisé pour convertir les noms de table en noms de classe, etc..
   */
  public static String convertToCamelCase(String line) 
  /**
   *Caractère spécifié(sep)Pour supprimer et convertir en CamelCase.
   *Remarque, utilisé pour convertir les noms de table en noms de classe, etc..
   */
  public static String convertToCamelCaseSep(String line,String sep) 
  /**
   *  _Supprimer et convertir en CamelCase avec un début inférieur.
   *Remarque, utilisé pour convertir les noms de colonnes en noms de champs, etc..
   */
  public static String columnToField(String name) 
  /**
   *Caractère spécifié(sep)Supprimer et convertir en CamelCase avec un début inférieur.
   *Remarque, utilisé pour convertir les noms de colonnes en noms de champs, etc..
   */
  public static String columnToFieldSep(String name,String sep) 
  /**
   *Supprimer le premier mot.
   *Supprimer le premier sep.
   */
  public static String removeFirst(String name,String sep) 
  /**
   *Supprimer le premier mot et sep et convertir en CamelCase.
   *Remarque, utilisé pour convertir les noms de table en noms de classe, etc..
   *Identique à deleteFirstWordToCamelCase.
   */
  public static String removeFirstWordToCamelCase(String name,String sep) 
  /**
   *Supprimez le premier mot et sep, convertissez en CamelCase et réduisez le début.
   *Remarque, utilisé pour convertir les noms de colonnes en noms de champs, etc..
   *Identique à deleteFirstWordToFieldSep.
   */
  public static String removeFirstWordToFieldSep(String name,String sep) {
  /**
   *Premier mot et plus_Supprimer, convertir en CamelCase et commencer par des minuscules.
   *Remarque, utilisé pour convertir les noms de colonnes en noms de champs, etc..
   */
  public static String removeFirstWordToField(String name)

Conversion EBCDIC

□ Conversion EBCDIC

ArStr.java


  /**Convertir la chaîne en EBCDIC. */
  public static byte[] toEbcdic(String value) 
  /**Convertir les nombres en EBCDIC. */
  public static byte[] toEbcdic(int val,int len) 
  /**Convertir EBCDIC en int*/
  public static Integer fromEbcdicToInt(byte[] bytes) 
  /**Convertir EBCDIC en chaîne*/
  public static String revertString(byte[] bytes) ```

#Date, heure, jour, vacances(jour férié), Calendrier japonais(05)

##Aperçu

Les classes associées sont les suivantes

##ArDate-Gérer uniquement les dates

1900/01/Prend en charge 01 ou version ultérieure.

###Aperçu

*Génération ArDate *Date d'ArDate,Calendar,Conversion en long *Conversion d'ArDate en chaîne *Calcul des jours ArDate *Processus de jugement ArDate *ArDate Autre

###Génération ArDate

*Génération avec date ou date actuelle

□ Génération en spécifiant la date et la date actuelles

ArDate.java


 / ** Constructeur. Obtenir la date actuelle. * /
  public ArDate() 
 / ** Constructeur. Généré en spécifiant AAAA, MM, JJ. * /
  public ArDate(int yyyy,int mm,int dd) 
 / ** Constructeur * /
  public ArDate(ArDate date)

□ Date,Calendar,Généré depuis longtemps

ArDate.java


 / ** Convertir à partir de constructor.java.util.Date. * /
  public ArDate(java.util.Date date) 
 / ** Convertir à partir de constructor.java.util.Calendar. * /
  public static ArDate(java.util.Calendar cal) 
 / ** Convertir à partir de constructor.long. * /
  public ArDate(long time)

□ Générer à partir d'une chaîne de caractères

ArDate.java


 / ** Constructeur. Conversion à partir d'une chaîne à l'aide de SimpleDateFormat. * /
  public static ArDate createFromString(String dateStr,String sdfStr) throws ParseException 
 / ** Constructeur. Conversion à partir d'une chaîne à l'aide de SimpleDateFormat. * /
  public static ArDate construct(String dateStr,String sdfStr) throws ParseException 
  /**
 * Constructeur. Convertir à partir d'une chaîne. Prend en charge les formats suivants.
 * aaaa / mm / jj ⇒ mm, jj peut être un seul chiffre.
 * aaaa-mm-jj ⇒ mm, jj peut être un chiffre.
 * aaaa: mm: jj ⇒ mm, jj peut être un seul chiffre.
 * aaa.mm.jj ⇒ mm, jj peut être un seul chiffre.
 * aaaa année mm mois jj jour ⇒ mm, jj peut être un seul chiffre.
 * aaaammjj ⇒ mm, jj sont deux chiffres.
 * S'il n'est pas dans le format ci-dessus, une RuntimeException se produira.
   */
  public static ArDate createFromString(String str) 
  /**
 * Constructeur. Convertir à partir d'une chaîne. Prend en charge les formats suivants.
 * aaaa / mm / jj ⇒ mm, jj peut être un seul chiffre.
 * aaaa-mm-jj ⇒ mm, jj peut être un chiffre.
 * aaaa: mm: jj ⇒ mm, jj peut être un seul chiffre.
 * aaa.mm.jj ⇒ mm, jj peut être un seul chiffre.
 * aaaa année mm mois jj jour ⇒ mm, jj peut être un seul chiffre.
 * aaaammjj ⇒ mm, jj sont deux chiffres.
 * S'il n'est pas dans le format ci-dessus, une RuntimeException se produira.
   */
  public static ArDate construct(String str)

□ Génération en précisant le jour

ArDate.java


  /**
 * Trouvez le nième jour du mois.
 * Renvoie null s'il n'existe pas.
   */
  public static ArDate nthOfYoubi(int year,int month,ArYoubi youbi,int n)

###Date d'ArDate,Calendar,Conversion en long

ArDate n'a pas d'heure, il sera donc 0:00, mais vous pouvez également spécifier l'heure pour la générer.

□ Date,Calendar,Conversion en long

ArDate.java


 / ** Convertir en java.util.Date. * /
  public java.util.Date toDate() 
 / ** Convertir en java.util.Date. * /
  public java.util.Date toDate(int hh,int mm,int ss) 
 / ** Convertir en java.util.Date. * /
  public java.util.Date toDate(long diff) 
 / ** Convertir en long. * /
  public long toLong() 
 / ** Convertir en long. * /
  public long toLong(int hh,int mm,int ss) 
 / ** Convertir en long. * /
  public long toLong(long diff) 
 / ** Convertir en java.util.Calendar. * /
  public java.util.Calendar toCalendar() 
 / ** Convertir en java.util.Calendar. * /
  public java.util.Calendar toCalendar(int hh,int mm,int ss) 
 / ** Convertir en java.util.Calendar. * /
  public java.util.Calendar toCalendar(long diff)

###Conversion d'ArDate en chaîne

□ Conversion en chaîne de caractères

ArDate.java


 / ** Convertir en aaaa / mm / jj. * /
  public String toString() 
  /**
 * Convertir en aaaa-mm-jj.
 * -Etc. Peut être spécifié avec sep. La date est toujours à 2 chiffres.
   */
  public String toString(String sep) 
 / ** Convertir en chaîne avec SimpleDateFormat. * /
  public String toStringBySDF(String sdfStr)

###Calcul des jours ArDate

*Avancer ou retarder ArDate du nombre de jours spécifié *Calculez le nombre de jours pour deux ArDates *Créer une liste d'ArDate *Les vacances peuvent être envisagées dans l'un des cas ci-dessus *Voir Ar Holiday pour le traitement des vacances

□ Avance ou retard du nombre de jours spécifié

ArDate.java


  /**
 * Avancez (retardez) le nombre de jours.
 * Changez votre propre objet.
   */
  public void forward(int n) {
  /**
 * Avancez (retardez) le nombre de jours.
 * Créez un nouvel objet.
   */
  public static ArDate forward(ArDate date,int days) 
  /**
 * Avancez (retardez) le nombre de jours.
 * Créez un nouvel objet.
   */
  public static ArDate constructForward(ArDate date,int days) 
  /**
 * Avancez (retardez) le nombre de jours.
 * Pensez aux vacances - changez votre objet.
   */
  public void forward(int n,ArHoliday holiday) 
  /**
 * Avancez (retardez) le nombre de jours.
 * Considération de vacances-Créer un nouvel objet.
   */
  public static ArDate forward(ArDate date,int days,ArHoliday holiday) 
  /**
 * Avancez (retardez) le nombre de jours.
 * Considération de vacances-Créer un nouvel objet.
   */
  public static ArDate constructForward(ArDate date,int days,ArHoliday holiday)

□ Calculez le nombre de jours

ArDate.java


  /**
 * Calcul du jour.
 * start <= end est un prérequis.
   */
  public static int days(ArDate start,ArDate end) 
  /**
 * Calcul du jour.
 * Pensez aux vacances.
 * start <= end est un prérequis.
   */
  public static int days(ArDate start,ArDate end,ArHoliday holiday)

□ Créer une liste d'ArDate

ArDate.java


 Renvoie une liste de jours jours à partir de / ** à partir deDate (y compris). Les jours ne peuvent pas être négatifs. La taille est de jours + 1 * /
  public static List<ArDate> dateList(ArDate fromDate,int days) 
 / ** Renvoie une liste de dates du au au * /
  public static List<ArDate> dateList(ArDate from,ArDate to) 
 Renvoie une liste de jours jours à partir de / ** deDate (y compris), sauf les jours fériés. En supposant que fromDate n'est pas un jour férié. Les jours ne peuvent pas être négatifs. La taille est de jours + 1. * /
  public static List<ArDate> dateList(ArDate fromDate,int days,ArHoliday holiday) 
 / ** Renvoie une liste de dates allant du au. Pensez aux jours fériés. * /
  public static List<ArDate> dateList(ArDate from,ArDate to,ArHoliday holiday)

###Processus de jugement ArDate

*Jugement de valeur égale entre ArDates, jugement de taille

□ Jugement de valeur égal, jugement de taille

ArDate.java


 / ** Jugement de valeur égal (égal lorsque la date est la même). * /
  @Override
  public boolean equals(Object o) 
  @Override
 / ** Comparaison de taille. * /
  public int compareTo(ArDate pair)

□ Jugement le même jour ignorant l'heure

ArDate.java


 / ** Détermine s'il s'agit de la même date que long. Idem même si long est au milieu de la journée. * /
  public boolean equals(long time) 
 / ** Déterminez si elle est identique à la date. La date est la même même si elle se situe au milieu de la journée. * /
  public boolean equals(Date date) 
 / ** Détermine s'il s'agit de la même date que Google Agenda. Idem même si Agenda est au milieu de la journée. * /
  public boolean equals(Calendar cal)

###ArDate Autre

ArDate.java


 / ** Trouver le jour (ArDate). * /
  public static ArYoubi youbi(ArDate date) 
 / ** Trouvez le nombre de jours dans le mois. * /
  public static int daysOfMonth(ArDate date) 
 / ** Trouvez le nombre de jours dans le mois. * /
  public static int daysOfMonth(int year,int month) 
 / ** Trouvez le nombre de jours dans une année. * /
  public static int daysOfYear(int year) 
 / ** Détermine s'il s'agit du dernier jour du mois. * /
  public static boolean isLastDay(ArDate date) 
 / ** Jugement de l'année Urui. * /
  public static boolean isLeapYear(int yyyy)

##ArDateUtil-Date et l'heure(Date,Calendar,long)Classes d'utilité associées

###Aperçu

*Obtenez la date et l'heure actuelles *Obtenez la date et l'heure spécifiées *Copie de la date⇔Calendrier *Arrondissez le temps *Avancer ou retarder l'heure *Jugement le même jour-Juger comme le même jour même si l'heure est différente *Jugement de l'heure actuelle-Spécification d'erreur *Jugement en même temps-Spécification d'erreur *Calcul du nombre de jours-Vous pouvez également envisager des vacances *Date après le nombre de jours spécifié,Calendar,Trouver longtemps-Vous pouvez également envisager des vacances *Demandez une liste entre deux dates-Vous pouvez également envisager des vacances *Demander une liste jusqu'au nombre de jours spécifié-Vous pouvez également envisager des vacances *Obtenez le jour *Convertir en chaîne-Ceux qui utilisent SimpleDateFormat *Convertir en chaîne *Conversion à partir de la chaîne *Contrôle d'existence

###Obtenez la date et l'heure actuelles

ArDateUtil.java


 / ** Obtenir la date de l'heure actuelle. * /
  public static Date getCurrentDate() 
 / ** Obtenir le calendrier de l'heure actuelle. * /
  public static Calendar getCurrentCalendar() 
 / ** Récupère la longueur de l'heure actuelle. * /
  public static long getCurrentTime() 
 / ** Obtenez le calendrier japonais du jour en cours * /
  public static ArWareki getCurrentWareki()

###Obtenez la date et l'heure spécifiées

ArDateUtil.java


 / ** Récupère la date de la date et de l'heure spécifiées. * /
  public static Date getDate(int year,int month,int day,int hour,int minute,int second) 
 / ** Obtenir le calendrier à la date et à l'heure spécifiées. * /
  public static Calendar getCalendar(int year,int month,int day,int hour,int minute,int second) 
 / ** Récupère la longueur de la date et de l'heure spécifiées. * /
  public static long getCurrentTime(int year,int month,int day,int hour,int minute,int second)

###Copie de la date⇔Calendrier

ArDateUtil.java


 / ** Date de copie * /
  public static Date copy(Date date) 
 / ** Copier le calendrier * /
  public static Calendar copy(Calendar cal) {
 / ** Convertit java.util.Date en java.util.Calendar. * /
  public static Calendar dateToCalendar(java.util.Date date) 
 / ** Convertit java.util.Calendar en java.util.Date. * /
  public static Date calendarToDate(java.util.Calendar cal)

###Arrondissez le temps

ArDateUtil.java


 / ** Réglé sur 0 heure, 0 minute et 0 seconde le jour. * /
  public static java.util.Date downTo0H0M0S(java.util.Date date) 
 / ** Réglé sur 0 heure, 0 minute et 0 seconde le jour. * /
  public static java.util.Calendar downTo0H0M0S(java.util.Calendar cal) 
 / ** Réglé sur 0 heure, 0 minute et 0 seconde le jour. * /
  public static long downTo0H0M0S(long time) 
 / ** Réglé sur zéro heure, zéro minute et zéro seconde le jour suivant. * /
  public static java.util.Date upTo0H0M0S(java.util.Date date) {
 / ** Réglé sur zéro heure, zéro minute et zéro seconde le jour suivant. * /
  public static java.util.Calendar upTo0H0M0S(java.util.Calendar cal) 
 / ** Réglé sur zéro heure, zéro minute et zéro seconde le jour suivant. * /
  public static long upTo0H0M0S(long time) 
 / ** Temps d'arrondi * /
  public static java.util.Date downTo0M0S(java.util.Date date) 
 / ** Temps d'arrondi * /
  public static java.util.Calendar downTo0M0S(java.util.Calendar cal) 
 / ** Temps d'arrondi * /
  public static long downTo0M0S(long time) 
 / ** Temps d'arrondi * /
  public static java.util.Date upTo0M0S(java.util.Date date) 
 / ** Temps d'arrondi * /
  public static java.util.Calendar upTo0M0S(java.util.Calendar cal) 
 / ** Temps d'arrondi * /
  public static long upTo0M0S(long time)

###Avancer ou retarder l'heure

ArDateUtil.java


 / ** Heure avancée. La date d'origine ne change pas. * /
  public static Date forward(Date date,int day,int hour,int minute,int second) 
 / ** Retarder l'heure. La date d'origine n'est pas modifiée. * /
  public static Date backward(Date date,int day,int hour,int minute,int second) 
 / ** Avancez l'heure. L'étalonnage d'origine ne change pas. * /
  public static Calendar forward(Calendar cal,int day,int hour,int minute,int second) 
 / ** Retarder l'heure. L'étalonnage d'origine ne change pas. * /
  public static Calendar backward(Calendar cal,int day,int hour,int minute,int second) 
 / ** Avancez l'heure. * /
  public static long forward(long time,int day,int hour,int minute,int second) 
 / ** Retarder l'heure. * /
  public static long backward(long time,int day,int hour,int minute,int second)

###Jugement le même jour-Juger comme le même jour même si l'heure est différente

ArDateUtil.java


 / ** Jugement le même jour (même si l'heure est différente) ArDate vs ArDate * /
  public static boolean sameDate(ArDate arDate0,ArDate arDate1) 
 / ** Jugement le même jour (même si l'heure est différente) ArDate vs Date * /
  public static boolean sameDate(ArDate arDate0,Date date) 
 / ** Jugement le même jour (même si l'heure est différente) ArDate vs Calendar * /
  public static boolean sameDate(ArDate arDate0,Calendar cal) 
 / ** Jugement le même jour (même si l'heure est différente) ArDate vs long * /
  public static boolean sameDate(ArDate arDate0,long time) 
 / ** Jugement le même jour (même si l'heure est différente) ArDate vs ArWareki * /
  public static boolean sameDate(ArDate arDate0,ArWareki wareki) 
 / ** Jugement le même jour (OK même si l'heure est différente) Date vs ArDate * /
  public static boolean sameDate(Date date0,ArDate arDate1) 
 / ** Jugement le même jour (OK même si l'heure est différente) Date vs Date * /
  public static boolean sameDate(Date date0,Date date1) 
 / ** Jugement le même jour (OK même si l'heure est différente) Date vs Calednar * /
  public static boolean sameDate(Date date,Calendar cal) 
 / ** Jugement le même jour (OK même si l'heure est différente) Date vs longue * /
  public static boolean sameDate(Date date,long time) 
 / ** Jugement le même jour (même si l'heure est différente) Date vs ArWareki * /
  public static boolean sameDate(Date date,ArWareki wareki) 
 / ** Jugement le même jour (même si l'heure est différente) Calendrier vs ArDate * /
  public static boolean sameDate(Calendar cal0,ArDate arDate1) 
 / ** Jugement le même jour (même si l'heure est différente) Calendrier vs Date * /
  public static boolean sameDate(Calendar cal0,Date date1) 
 / ** Jugement le même jour (même si l'heure est différente) Calendrier vs Calendrier * /
  public static boolean sameDate(Calendar cal0,Calendar cal1) 
 / ** Jugement le même jour (OK même si l'heure est différente) Calendrier vs long * /
  public static boolean sameDate(Calendar cal,long time) 
 / ** Jugement le même jour (même si l'heure est différente) Calendar vs ArWareki * /
  public static boolean sameDate(Calendar cal,ArWareki wareki) 
 / ** Jugement le même jour (OK même si l'heure est différente) long vs ArDate * /
  public static boolean sameDate(long time0,ArDate arDate1) 
 / ** Jugement le même jour (OK même si l'heure est différente) long vs Date * /
  public static boolean sameDate(long time0,Date date1) 
 / ** Jugement le même jour (OK même si l'heure est différente) long vs calendrier * /
  public static boolean sameDate(long time0,Calendar cal1) 
 / ** Jugement le même jour (OK même si l'heure est différente) long vs long * /
  public static boolean sameDate(long time0,long time1) 
 / ** Jugement le même jour (OK même si l'heure est différente) long vs ArWareki * /
  public static boolean sameDate(long time0,ArWareki wareki) 
 / ** Jugement le même jour (même si l'heure est différente) ArWareki vs ArDate * /
  public static boolean sameDate(ArWareki wareki0,ArDate arDate1) 
 / ** Jugement le même jour (même si l'heure est différente) ArWareki vs Date * /
  public static boolean sameDate(ArWareki wareki0,Date date1) 
 / ** Jugement le même jour (même si l'heure est différente) ArWareki vs Calendar * /
  public static boolean sameDate(ArWareki wareki0,Calendar cal1) 
 / ** Jugement le même jour (même si l'heure est différente) ArWareki vs long * /
  public static boolean sameDate(ArWareki wareki0,long time1) 
 / ** Jugement le même jour (même si l'heure est différente) ArWareki vs ArWareki * /
  public static boolean sameDate(ArWareki wareki0,ArWareki wareki1)

###Jugement de l'heure actuelle-Spécification d'erreur

ArDateUtil.java


 / ** Jugement de l'heure actuelle-Erreur (minute) spécification-Date * /
  public static boolean currentTime(Date date,int min) 
 / ** Jugement de l'heure actuelle-Erreur (minute) spécification-Calendrier * /
  public static boolean currentTime(Calendar cal,int min) 
 / ** Jugement de l'heure actuelle-Erreur (minute) spécification-long * /
  public static boolean currentTime(long time,int min)

###Jugement en même temps-Spécification d'erreur

ArDateUtil.java


 / ** Jugement en même temps-Erreur (minute) spécification-Date vs Date * /
  public static boolean sameTime(Date date0,Date date1,int min) 
 / ** Jugement de la même heure - Spécification d'erreur (minute) - Date vs calendrier * /
  public static boolean sameTime(Date date0,Calendar cal1,int min) 
 / ** Jugement en même temps-Erreur (minute) spécification-Date vs longue * /
  public static boolean sameTime(Date date0,long time1,int min) 
 / ** Jugement de la même heure - Spécification d'erreur (minute) - Calendrier vs Date * /
  public static boolean sameTime(Calendar cal0,Date date1,int min) 
 / ** Jugement en même temps-Erreur (minute) spécification-Calendrier vs Calendrier * /
  public static boolean sameTime(Calendar cal0,Calendar cal1,int min) 
 / ** Même temps de jugement-Erreur (minute) Spécification-Calendrier vs long * /
  public static boolean sameTime(Calendar cal0,long time1,int min) 
 / ** Erreur de jugement dans le même temps (minute) spécification longue par rapport à la date * /
  public static boolean sameTime(long time0,Date date1,int min) 
 / ** Erreur de jugement dans le même temps (minute) spécification longue par rapport au calendrier * /
  public static boolean sameTime(long time0,Calendar cal1,int min) 
 / ** Erreur de jugement dans le même temps (minute) spécification longue / longue
  public static boolean sameTime(long time0,long time1,int min)

###Calcul du nombre de jours-Vous pouvez également envisager des vacances

ArDateUtil.java


 / ** Calculez le nombre de jours pour deux dates. * /
  public static int days(Date from,Date to) 
 / ** Calculez le nombre de jours pour deux dates. Pensez aux vacances * /
  public static int days(Date from,Date to,ArHoliday holiday) 
 / ** Calculez le nombre de jours pour deux calendriers. * /
  public static int days(Calendar from,Calendar to) 
 / ** Calculez le nombre de jours pour deux calendriers. Pensez aux jours fériés * /
  public static int days(Calendar from,Calendar to,ArHoliday holiday) 
 / ** Calculez le nombre de jours pour deux longs. * /
  public static int days(long from,long to) 
 / ** Calculez le nombre de jours pour deux longs. Pensez aux vacances * /
  public static int days(long from,long to,ArHoliday holiday)

###Date après le nombre de jours spécifié,Calendar,Trouver longtemps-Vous pouvez également envisager des vacances

ArDateUtil.java


 / ** Rechercher la date après jours. Les heures, les minutes et les secondes sont conservées. * /
  public static Date days(Date from,int days) 
 / ** Rechercher la date après jours. Tenez compte des jours fériés. Les heures, les minutes et les secondes sont conservées. * /
  public static Date days(Date from,int days,ArHoliday holiday) 
 / ** Rechercher le calendrier après des jours. Les heures, les minutes et les secondes sont conservées. * /
  public static Calendar days(Calendar from,int days) 
 / ** Rechercher le calendrier après des jours. Tenez compte des jours fériés. Les heures, les minutes et les secondes sont conservées. * /
  public static Calendar days(Calendar from,int days,ArHoliday holiday) 
 / ** Recherche longtemps après jours. Les heures, les minutes et les secondes sont conservées. * /
  public static long days(long from,int days) 
 / ** Recherche après plusieurs jours. Pensez aux jours fériés. Les heures, les minutes et les secondes sont conservées. * /
  public static long days(long from,int days,ArHoliday holiday)

###Demandez une liste entre deux dates-Vous pouvez également envisager des vacances

ArDateUtil.java


 / ** Demandez une liste entre deux dates * /
  public static List<ArDate> dateList(ArDate from,ArDate to) 
 / ** Demandez une liste entre deux dates - pensez aux vacances * /
  public static List<ArDate> dateList(ArDate from,ArDate to,ArHoliday holiday) 
 / ** Trouver une liste entre deux dates-heures, minutes et secondes sont les mêmes qu'à partir de * /
  public static List<Date> dateList(Date from,Date to) 
 / ** Demandez une liste entre deux dates - considérez les jours fériés - les heures, les minutes et les secondes sont les mêmes qu'à partir de * /
  public static List<Date> dateList(Date from,Date to,ArHoliday holiday) 
 / ** Trouver une liste entre deux dates-heures, minutes et secondes sont les mêmes qu'à partir de * /
  public static List<Calendar> dateList(Calendar from,Calendar to) 
 / ** Demandez une liste entre deux dates - considérez les jours fériés - les heures, les minutes et les secondes sont les mêmes qu'à partir de * /
  public static List<Calendar> dateList(Calendar from,Calendar to,ArHoliday holiday) 
 / ** Trouver une liste entre deux dates-heures, minutes et secondes sont les mêmes qu'à partir de * /
  public static List<Long> dateList(long from,long to) 
 / ** Demandez une liste entre deux dates - considérez les jours fériés - les heures, les minutes et les secondes sont les mêmes qu'à partir de * /
  public static List<Long> dateList(long from,long to,ArHoliday holiday)

###Demander une liste jusqu'au nombre de jours spécifié-Vous pouvez également envisager des vacances

ArDateUtil.java


 Renvoie une liste de dates de jours jours à partir de / ** à partir de (y compris). La taille de la liste est de jours + 1. Les heures, les minutes et les secondes sont conservées. * /
  public static List<Date> dateList(Date from,int days) 
 Renvoie une liste de dates de jours jours à partir de / ** à partir de (y compris). La taille de la liste est de jours + 1. Tenez compte des jours fériés. Les heures, les minutes et les secondes sont conservées. * /
  public static List<Date> dateList(Date from,int days,ArHoliday holiday) 
 Renvoie une liste d'agendas pour jours jours à partir de / ** à partir de (y compris). La taille de la liste est de jours + 1. Les heures, les minutes et les secondes sont conservées. * /
  public static List<Calendar> dateList(Calendar from,int days) 
 Renvoie une liste d'agendas pour jours jours à partir de / ** à partir de (y compris). La taille de la liste est de jours + 1. Tenez compte des jours fériés. Les heures, les minutes et les secondes sont conservées. * /
  public static List<Calendar> dateList(Calendar from,int days,ArHoliday holiday) 
 Renvoie une longue liste de jours jours à partir de / ** à partir de (y compris). La taille de la liste est de jours + 1. Les heures, minutes et secondes sont conservées. * /
  public static List<Long> dateList(long from,int days) 
 Renvoie une longue liste de jours jours à partir de / ** à partir de (y compris). La taille de la liste est de jours + 1. Tenez compte des jours fériés. Les heures, les minutes et les secondes sont conservées. * /
  public static List<Long> dateList(long from,int days,ArHoliday holiday)

###Obtenez le jour

ArDateUtil.java


 / ** Obtenez la journée. * /
  public static ArYoubi getYoubi(ArDate arDate) 
 / ** Obtenez la journée. * /
  public static ArYoubi getYoubi(Date date) 
 / ** Obtenez la journée. * /
  public static ArYoubi getYoubi(Calendar cal) 
 / ** Obtenez la journée. * /
  public static ArYoubi getYoubi(long time) 
 / ** Obtenez la journée. * /
  public static ArYoubi getYoubi(ArWareki wareki)

###Convertir en chaîne-Ceux qui utilisent SimpleDateFormat

ArDateUtil.java


 / ** Remplacez $ {DATExxxx} par la date et l'heure actuelles. Xxxx est un format géré par SimpleDateFormat. * /
  public static String replaceByDate(String str) 
 / ** Remplacez $ {DATExxxx} par la date et l'heure, etc. xxxx est un format géré par SimpleDateFormat. * /
  public static String replaceByDate(String str,ArDate date) 
 / ** Remplacez $ {DATExxxx} par la date et l'heure, etc. xxxx est un format géré par SimpleDateFormat. * /
  public static String replaceByDate(String str,java.util.Calendar cal) 
 / ** Remplacez $ {DATExxxx} par la date et l'heure, etc. xxxx est un format géré par SimpleDateFormat. * /
  public static String replaceByDate(String str,long time) 
 / ** Remplacez $ {DATExxxx} par la date et l'heure, etc. <br> xxxx est un format géré par SimpleDateFormat <br> * /
  public static String replaceByDate(String str,java.util.Date date)

###Convertir en chaîne

ArDateUtil.java


 / ** Convertit ArDate en date et heure. * /
  public static String toString(ArDate date) 
 / ** Convertit une date et une heure longues
  public static String toString(long time) 
 / ** Convertit java.util.Date en date et heure. * /
  public static String toString(java.util.Date utilDate) 
 / ** Convertit java.util.Calendar en date et heure. * /
  public static String toString(java.util.Calendar cal)

###Conversion à partir de la chaîne

ArDateUtil.java


  /**
 * Convertissez la chaîne en java.util.Date.
 * Le format de la chaîne de caractères cible est défini dans ArDateFormats et ArTimeFormats.
   */
  public static java.util.Date toDate(String str) 
  /**
 * Convertissez la chaîne en java.util.Calendar.
 * Le format de la chaîne de caractères cible est défini dans ArDateFormats et ArTimeFormats.
   */
  public static Calendar toCalendar(String str) 
  /**
 * Convertissez la chaîne en long.
 * Le format de la chaîne de caractères cible est défini dans ArDateFormats et ArTimeFormats.
   */
  public static Long toLong(String str)

###Contrôle d'existence

ArDateUtil.java


 / ** Vérifier l'existence du temps. * /
  public static boolean isValidTime(int hour,int minite,int second) 
 / ** Vérifiez l'existence de la date. 1900-2100 * /
  public static boolean isValidDate(int year,int month,int date) 
 / ** Vérifiez l'existence de la date et de l'heure. * /
  public static boolean isValidDateTime(int year,int month,int date,int hour,int minite,int second)

##ArYoubi-Énumération des jours

###Aperçu

*Obtenez le jour actuel, obtenez le jour suivant *Conversion mutuelle avec valeur int, personnalisation de la valeur de conversion *Conversion mutuelle avec valeur de chaîne, jour/Anglais et forme longue/Forme courte

###Obtenez le jour actuel, obtenez le jour suivant

ArYoubi.java


 / ** Trouver le jour actuel. * /
  public static ArYoubi getCurrentYoubi() 
 / ** Trouver le lendemain. * /
  public ArYoubi next()

###Conversion mutuelle avec valeur int, personnalisation de la valeur de conversion

*La valeur par défaut pour la conversion est définie sur ArYoubiInt *Si vous définissez une valeur pour intConversion, elle sera convertie en fonction de celle-ci.

ArYoubi.java


  /**
 * Conversion de int en jour.
 * Renvoie null si la valeur est incorrecte.
 * Si intConversion est défini, convertissez en fonction de celui-ci.
   */
  public static ArYoubi fromInt(int youbi) 
 / ** Convertit le jour en entier. * /
  public int toInt()

###Conversion mutuelle avec valeur de chaîne, jour/Anglais et forme longue/Forme courte

*Le format court est jour, soleil, etc. *Le format long est dimanche, dimanche, etc.

ArYoubi.java


  /**
 * Convertir en une chaîne.
 * lang spécifie la langue. Spécifie JAPONAIS ou ANGLAIS de Lang.
 * longth spécifie la forme courte ou la forme longue. Spécifiez LONG ou SHORT de Longueur.
 * Entourez avant et après le crochet spécifié par crochet. En supposant que BRACKETx de CharDef est spécifié. Si null est spécifié, il ne sera pas inclus.
   */
  public String toString(int lang,int length,String[] bracket) 
 / ** Renvoie la forme courte japonaise.
  public String toJShortString() 
  /**
 * Conversion du formulaire japonais unique en Youbi.
 * Renvoie null s'ils ne correspondent pas.
   */
  public static ArYoubi fromJShortString(String str) 
 / ** Renvoie le formulaire long japonais. * /
  public String toJLongString() 
  /**
 * Conversion de la forme longue japonaise en Youbi.
 * Renvoie null s'ils ne correspondent pas.
   */
  public static ArYoubi fromJLongString(String str) 
 / ** Retourne la forme abrégée en anglais. * /
  public String toEShortString() 
  /**
 * Conversion du formulaire simple anglais en Youbi.
 * Renvoie null s'ils ne correspondent pas.
   */
  public static ArYoubi fromEShortString(String str) 
 / ** Renvoie le formulaire long en anglais. * /
  public String toELongString() 
  /**
 * Conversion de la forme longue anglaise en Youbi.
 * Renvoie null s'ils ne correspondent pas.
   */
  public static ArYoubi fromELongString(String str)

##ArHoliday-Interface de traitement des vacances(La classe d'implémentation est également fournie)

###Aperçu

ArHoliday-Interface de traitement des vacances

ArHoliday.java


package jp.avaj.lib.algo;

import java.util.List;

 / ** Interface de traitement du jugement de vacances * /
public interface ArHoliday {
  /**
 * Obtenez des informations sur les vacances.
 * En vacances ⇒HolidayInfo.isHoliday est vrai.
 * Les jours ouvrables ⇒ HolidayInfo.isHoliday est faux.
 * Lorsqu'elle ne peut pas être déterminée ⇒ La valeur de retour est nulle.
   */
  public ArHolidayInfo get(ArDate date);
  /**
 * Obtenez des informations sur les vacances pour l'année et le mois concernés.
 * Les informations sur les jours fériés et les jours ouvrables sont acquises.
 * N'inclut pas les jours qui ne peuvent être déterminés.
   */
  public List<ArHolidayInfo> get(int year,int month);
  /**
 * Obtenez des informations de vacances pour l'année.
 * Les informations sur les jours fériés et les jours ouvrables sont acquises.
 * N'inclut pas les jours qui ne peuvent être déterminés.
   */
  public List<ArHolidayInfo> get(int year);

}

ArHolidayInfo-Classe d'information sur les vacances

ArHolidayInfo.java


package jp.avaj.lib.algo;

 / ** Informations vacances * /
public class ArHolidayInfo {
 / ** Date. * /
  public ArDate date;
 / ** Vacances? . * /
  public Boolean isHoliday;
 /** La description. */
  public String descr;
}

###Différentes classes d'implémentation d'ArHoliday

Vous pouvez créer vos propres classes d'implémentation, mais la bibliothèque Artery fournit:

ArHolidayStandard-Combinez d'autres classes d'implémentation ArHoliday

*Vacances complexes combinées à d'autres classes d'implémentation/Atteindre les conditions de la journée de travail *Examiner les classes spécifiées dans l'ordre *Si vous ne pouvez pas décider, regardez le prochain cours

##ArWareki-Traitement du calendrier japonais

*Correspondant à après le 1er janvier 1897 *Générer ArWareki pour la journée en cours *Coby d'ArWareki

###référence:Correspondance entre calendrier japonais et calendrier occidental

*1er janvier 1873 ⇔ 1er janvier 1873. *30 juillet 1912 ⇔ 30 juillet 1912. *25 décembre 1926 ⇔ 25 décembre 1926. *8 janvier 2001 ⇔ 8 janvier 1989. *1 mai 2019 ⇒ 1 mai 2019.

Notez que le calendrier Julius est utilisé jusqu'à la 5ème année de l'ère Meiji et que la date ne correspond pas au calendrier occidental..

###Générer ArWareki pour la journée en cours

ArWareki.java


 / ** Génère le calendrier japonais du jour en cours * /
  public static ArWareki construct()

###Coby d'ArWareki

ArWareki.java


 / ** Constructeur * /
  public ArWareki(ArWareki wareki)

ArDate,Date,Calendar,Générer ArWareki à partir de

ArWareki.java


 / ** Conversion du calendrier occidental au calendrier japonais. * /
  public static ArWareki fromArDate(ArDate date) 
 / ** Convertit java.util.Date en calendrier japonais. * /
  public static ArWareki fromDate(java.util.Date utilDate) 
 / ** Convertit java.util.Calendar en calendrier japonais. * /
  public static ArWareki fromCalendar(java.util.Calendar cal) 
 / ** Conversion du calendrier long en calendrier japonais. * /
  public static ArWareki fromLong(long time)

###ArWareki à ArDate,Date,Calendar,Générer longtemps(Les heures, minutes et secondes sont égales à 0)

ArWareki.java


 / ** Conversion du calendrier japonais en calendrier occidental. * /
  public ArDate toArDate() 
 / ** Conversion du calendrier japonais en java.util.Date (0:00:00). * /
  public static java.util.Date toDate(ArWareki wareki) 
 / ** Conversion du calendrier japonais en java.util.Calendar (0:00:00). * /
  public static java.util.Calendar toCalendar(ArWareki wareki) 
 / ** Conversion du calendrier japonais en calendrier long (0:00:00). * /
  public static long toLong(ArWareki wareki)

###Obtenez la journée d'ArWareki

ArWareki.java


 / ** Obtenir le jour * /
  public ArYoubi getYoubi()

###ArWareki et ArDate,Date,Calendar,Jugement le même jour avec long

ArWareki.java


 / ** Jugement le même jour (ArWareki) * /
  public boolean sameDate(ArWareki wareki) 
 / ** Jugement le même jour (ArDate) * /
  public boolean sameDate(ArDate arDate) 
 / ** Jugement le même jour (Date) * /
  public boolean sameDate(Date date) 
 / ** Jugement le même jour (calendrier) * /
  public boolean sameDate(Calendar cal) 
 / ** Jugement le même jour (long) * /
  public boolean sameDate(long time)

#Autre/interface

###Aperçu

#Autre/classe

#Autre/Type d'énumération

#Copier des valeurs entre des beans()

-La valeur est fréquemment copiée dans le processus entre écran ⇔ logique métier ⇔ DB. Il y a les problèmes suivants ici. -Les noms de champs sont différents. -Le type de champ est différent. -Même dans le même type de champ, la signification de la valeur est différente. Exemple,(Masculin:0,Femme:1)⇒(Masculin:1,Femme2)。 -Il y a des champs que vous ne souhaitez pas copier. -Si un tel traitement est décrit individuellement, les méthodes seront différentes et les bogues seront plus susceptibles de se produire. -Un traitement similaire est décrit à divers endroits. ・ Il est souhaitable d'améliorer la qualité en la rendant commune et en pièces autant que possible.

・Exemple d'utilisation d'ArAutoValueConverter(Conversion de type de champ) ・[ArValueConverter(Classe d'implémentation)Exemple d'utilisation-Convertir un objet en un autre objet / conversion inverse] ・[Copie du champ du même nom(Conversion de type de champ-Utilisation d'ArAutoValueConverter)] ・[Copier entre les beans-Copie de champs avec des noms différents(Spécifiez les informations de conversion et convertissez avec ArValueConverter)] ・(C'est extra)[Définissez le créateur / la date / heure de création et la date / heure de mise à jour / mise à jour du bean.]

#Traitement graphique()

###Classe connexe ・ ArGraphPointType ⇒ Définition du type de point(début/Fin/début＆Fin/Qui passe) ・ ArGraphEdge ⇒ Bord ・ ArGraphEdgeDir ⇒ Direction du bord(Bidirectionnel/Une manière/Pas de sens) ・ ArGraphConnection ⇒Informations de connexion des points(Destination de connexion et source de connexion) ・ ArGraph ⇒ Logique de traitement

###Méthode ArGraph

ArGraph.java


 / ** Effectue un tri topologique. Null est renvoyé en cas de boucle * /
  public static <$Point> List<$Point> topologicalSort(Collection<ArGraphEdge<$Point>> edges)
  /**
 * Fractionner un graphe non lié. S'il s'agit d'un graphe connecté, un seul graphe sera renvoyé.
 * @param pontMap Informations sur les points, obtenezAllPoints à l'avance.
   */
  public static <$Point> List<Map<$Point,ArGraphConnection<$Point>>> divide(Collection<ArGraphEdge<$Point>> edges) {
  /**
 * Fractionner un graphe non lié. S'il s'agit d'un graphe connecté, un seul graphe sera renvoyé.
 * @param pontMap Informations sur les points, obtenezAllPoints à l'avance.
   */
  public static <$Point> List<Map<$Point,ArGraphConnection<$Point>>> divide(Map<$Point,ArGraphConnection<$Point>> pointMap)
  /**
 * Trouvez l'itinéraire entre les points spécifiés.
 * @param pontMap Informations sur les points, obtenezAllPoints à l'avance.
 * @param targetPoints Points de passage, [0]: origine, [n-1]: destination
   */
  public static <$Point> List<List<$Point>> findRoute(Collection<ArGraphEdge<$Point>> edges,$Point[] targetPoints)
  /**
 * Trouvez l'itinéraire entre les points spécifiés.
 * @param pontMap Informations sur les points, obtenezAllPoints à l'avance.
 * @param targetPoints Points de passage, [0]: origine, [n-1]: destination
   */
  public static <$Point> List<List<$Point>> findRoute(Map<$Point,ArGraphConnection<$Point>> pointMap,$Point[] targetPoints) 
  /**
 * Déterminez si la route est fermée.
 * @return Si vrai, fermé, mais il peut y avoir plusieurs fermés.
   */
  public static <$Point> boolean closed(Collection<ArGraphEdge<$Point>> edges) 
 / ** Demande des informations sur le point de départ. Y compris ceux qui servent également de point de départ et de point d'arrivée. Taille zéro si elle n'existe pas. * /
  public static <$Point> Map<$Point,ArGraphConnection<$Point>> getStartPoints(Collection<ArGraphEdge<$Point>> edges) {
 / ** Rechercher des informations sur les points d'arrivée. Y compris ceux qui servent également de points de départ et d'arrivée. Taille zéro si elle n'existe pas. * /
  public static <$Point> Map<$Point,ArGraphConnection<$Point>> getEndPoints(Collection<ArGraphEdge<$Point>> edges) 
 / ** Recherche des informations sur le point de départ du point final. Taille zéro si elle n'existe pas * /
  public static <$Point> Map<$Point,ArGraphConnection<$Point>> getStartEndPoints(Collection<ArGraphEdge<$Point>> edges) 
 / ** Obtenir toutes les informations sur les points * /
  public static <$Point> Map<$Point,ArGraphConnection<$Point>> getAllPoints(Collection<ArGraphEdge<$Point>> edges)

###échantillon

・Traitement graphique(Ligne de chemin de fer)-Jugement de clôture/Recherche de point final de point de départ/Division de l'itinéraire/Tri topologique/Recherche d'itinéraire entre les stations

#Divers divers(08)

###combinaison(Combination)

・combinaison(ArCombination)Génération(Q08_00)

###Machine d'état

・Exemple de machine d'état(Q08_01)

###Traitement du tableau numérique

・Traitement du tableau numérique-Agrégation(Valeur maximale, valeur minimale, totale, moyenne, écart type),conversion(Moyenne mobile, taux de changement, etc.), Histogramme, etc.

Recommended Posts

Échantillon de bibliothèque d'algorithmes Java
Échantillon de bibliothèque de tests unitaires Java
Java
Java
Résumé de l'algorithme AtCoder 400 points (édition Java)
Apprendre Java (0)
Étudier Java ―― 3
[Java] tableau
Java protégé
[Java] Annotation
Module [Java]
Tableau Java
Étudier Java ―― 9
Java scratch scratch
Astuces Java, astuces
Méthodes Java
Méthode Java
java (constructeur)
Tableau Java
[Java] ArrayDeque
java (remplacement)
java (méthode)
Chaîne Java
java (tableau)
Sérialisation Java
java débutant 4
JAVA payé
Gymnastique algorithmique 1
Étudier Java ―― 4
Java (ensemble)
tri shell java
[Java] compareTo
Étudier Java -5
java réfléchissant 获 获 举
java (interface)
Mémorandum Java
Tableau Java
Étudier Java ―― 1
[Java] Polymorphisme
Étudier Java # 0
Revue Java
Fonctionnalités Java
[Java] Héritage
FastScanner Java
Fonctionnalités Java
java débutant 3
Mémo Java
java (encapsulation)
Héritage Java
[Java] Surcharge
Les bases de Java
Décompiler Java
[Java] Annotation
note java
java débutant
Java (add2)
JAVA (Carte)
interface [java]
Collection Java9
Les bases de Java