J'ai essayé de traduire la grammaire de R et Java [Mis à jour de temps en temps]

Préface

Qu'est-ce que c'est?

Il s'agit d'une comparaison de la grammaire de ** R **, qui est un langage spécialisé pour le traitement et l'analyse de données statistiques, avec le format de ** Java **, qui est un langage à usage général. Veuillez vous y référer afin que les personnes qui comprennent Java puissent l'utiliser quand elles veulent écrire R.

Connaissances préalables requises (côté Java)

・ Comprendre les types de variables (int, double, booléen, chaîne, autour de l'objet) ・ Comprendre les tableaux multidimensionnels ・ La liste et la carte peuvent être utilisées (un exemple de code est utilisé) ・ Extended pour l'instruction [Java 8] peut être utilisé (comme ci-dessus)

Si vous dites ce que vous voulez faire avec R, vous comprendrez si cette zone est maintenue enfoncée.

Connaissances préalables requises (côté R)

・ R installé ・ Je sais qu'il n'y a pas besoin d'un point-virgule à la fin de la phrase. ・ Yaruki

Dictionnaire opposé R-Java

Grammaire à usage général

Commun à Java et R

・ ** Opérateurs arithmétiques autres que ceux liés à la division ** (+, -, *) -Opérateur de comparaison (<,>, <=,> = ,! =) ・ Opérateur logique conditionnel(&&, ||), Opérateur logique(&, |),le déni(!)

Différentes choses

Remarque

• 1: Dans R, même si vous divisez entre des types entiers, il sera renvoyé sous forme de type à virgule flottante (double), donc si vous entrez simplement 10/4, par exemple, 2,5 sera renvoyé.
• 2: Soyez prudent lorsque vous comptez sur l'auto-complétion car il existe une fonction similaire mais complètement différente appelée readLines (). De plus, si elle n'est pas interactive avec la console, cette description sera ignorée et le traitement suivant se poursuivra en supposant qu'une chaîne de caractères vide a été saisie. Vous pouvez vérifier s'il est interactif avec print (interactive ()).
• 3: Lors d'un commentaire sur plusieurs lignes, il est nécessaire de mettre # dans toutes les lignes.

if, for, instruction switch

if_for_switch.java

if(statement){
  System.out.println(statement is true);
}

for(int i=0;i<n;i++){
  System.out.println("for loop " + i);
}

switch(num){
  case 0:
    System.out.println("switch num=0");
    break;
  case 1:
    System.out.println("switch num=1");
    break;
  default:
    System.out.println("switch default");
}

if_for_switch.R

if(statement){
  print("statement is TRUE")
}

for(i in 1:n){
  print(paste("for loop ", i-1))
}

switch(num,
  "0" = {print("switch num=0")},
  "1" = {print("switch num=1")},
  {print("switch default")}
)

Remarque Comme dans la sortie standard de l'instruction R for, il n'est pas possible de sortir une chaîne et une valeur numérique reliées par + (à proprement parler, ce n'est pas recommandé même en Java). Utilisez la méthode paste (). {} Dans chaque instruction de l'instruction R switch, elle peut être omise si le contenu est une seule instruction.

Comment appeler chaque élément d'un tableau à deux dimensions (R: matrice)

matrix.java

int[][] a = new int[4][4];

matrix.R

a <- matrix(ncol=4, nrow=4)

Les deux ont presque la même apparence (il existe des différences telles que «0» si la valeur initiale est java et «NA» si c'est R. Dans le cas de R, la valeur prise par le contenu du type de matrice est une valeur numérique. Pas exclusivement) Comment faire référence à chaque élément de cette matrice est la suivante.

Éliminer l'utilisation des déclarations for (appliquer la famille)

Si vous n'utilisez pas l'instruction for, c'est comme R pour une personne, mais c'est difficile à expliquer, alors voyons ce que fait la famille apply par opposition à Java.

Appliquer la fonction à chaque élément d'un tableau multidimensionnel

apply.java

//Génération de séquence et initialisation à partir d'ici
int[][] mtrx = new int[4][4];
for(int i=0;i<4;i++){
  for(int j=0;j<4;i++){
    mtrx[i][j] = i * 4 + j;
  }
}
//Jusque là
//Préparation des fonctions à appliquer à plusieurs reprises à partir d'ici
int add(int i){
  return i+1;
}
//Jusque là
//De là, scannez le tableau et appliquez la fonction
for(int i=0;i<4;i++){
  for(int j=0;j<4;i++){
    mtrx[i][j] = add(mtrx[i][j]);
  }
}
//Jusque là

Un tableau bidimensionnel contenant les nombres de 0 à 15 est généré, et 1 est ajouté à chaque élément (bien sûr, c'est une manière ébouriffante d'expliquer en comparaison ~ ~ Il est écrit de manière redondante. ).

apply.R

#Génération de matrice et initialisation à partir d'ici
a <- matrix(c(1:16), ncol=4, nrow=4, byrow=TRUE)
#Jusque là
#Préparation des fonctions à appliquer à plusieurs reprises à partir d'ici
add <- function(i){
  return(i+1)
}
#Jusque là
#De là, scannez la matrice et appliquez la fonction
apply(a, c(1,2), add)
#Jusque là

Cela peut être écrit très simplement comme ça. J'ai créé une fonction qui s'exécute à plusieurs reprises ici, mais vous pouvez utiliser n'importe laquelle des fonctions disponibles (par exemple, sqrt vous donne une matrice avec les racines carrées de tous les éléments).

Remarque -L'option byrow de la fonction matrix () est une option pour organiser le vecteur source (c (1:16) dans cet exemple) pour être une matrice en unités de ligne. La valeur par défaut est FALSE, donc la matrice obtenue en exécutant ce code est transposée. -La deuxième option (c (1: 2)) de la fonction ʻapply () `spécifie la portée. Faites de même avec 1 pour «toutes les lignes» et 2 pour «toutes les colonnes». ** Si vous voulez juste tourner une boucle for sur un tableau à deux dimensions, vous n'avez pas à vous en soucier du tout, alors ne vous embêtez pas avec insouciance **. Plus précisément, les deux codes suivants font à peu près la même chose. R est vraiment juste ça, pas d'écrasement.

apply2.java

int sum(int[] arr){  //Une fonction qui donne la somme des tableaux. R vient de série
  int sum = 0;
  for(int i : arr){
    sum += i;
  }
  return sum;
}

int[] sum_arr = new int[4];
for(int i=0;i<4;i++){
  sum_arr[i] = sum(mtrx[i]);  //Somme pour toutes les lignes()Appliquer la fonction
}

apply2.R

apply(a, 1, sum)

Appliquer la fonction à chaque élément de HashMap (lapply)

Tout d'abord, il est nécessaire de comprendre que les variables de type liste dans R ** n'ont pas besoin d'avoir le même type de valeurs contenues dans **. En d'autres termes, c'est comme déclarer que Java Map gère les types d'objets à moins que vous ne déclariez quoi que ce soit en particulier.

lapply.java

Map<String, Object> a = new HashMap<>();
a.put("i", 123);
a.put("d", 4.56d);
a.put("b", false);

lapply.R

a <- list(i = 123, d = 4.56, b = FALSE)

De cette manière, il est possible d'avoir un type entier, un type virgule flottante double précision et un type logique en même temps. lapply effectue le traitement des listes et des matrices et ** renvoie les résultats sous forme de liste **.

lapply2.java

Map<String, Object> a = new HashMap<>();
a.put("i", 123);
a.put("d", 4.56d);
a.put("b", false);

for(Object o : a.values()){
  add(o);
}    //Erreur de compilation!

lapply2.R

a <- list(i = 123, d = 4.56, b = FALSE)

lapply(a, add) #add()La fonction est appliquée.Détourné de R

Puisque l'argument de la fonction add () définie dans apply.java est de type int, le code ci-dessus ne peut pas être exécuté en Java. Cependant, dans R, il n'y a pas besoin de déclaration de type et la variable est automatiquement mise en correspondance avec le type le plus grand, de sorte que ce code peut être exécuté (traité comme FALSE = 0, TRUE = 1), et la sortie est la suivante. À.

> lapply(a, add)
$i
[1] 124

$d
[1] 5.56

$b
[1] 1

Vous pouvez utiliser lapply pour les tableaux 2D, mais ce sera gênant à moins que vous n'ayez besoin de générer un type de liste. Vous pouvez supposer que c'est une telle fonction. Pour la matrice 4x4 générée par apply.java (apply.R), les deux lapply () suivants produisent presque la même chose.

lapply3.java

Map<String, Integer> lapply(int[][] arr){
  Map<String, Integer> a = new HashMap<>();
  for(int i=0;i<arr[0].length;i++){
    for(int j=0;j<arr.length;j++){
      a.put(String.valueOf(i * 4 + j + 1), add(arr[j][i]));
      //arr[i][j]Pas arr[j][i]Notez que
      //Dans R, la recherche de tableaux à deux dimensions se fait colonne par colonne
    }
  }
  return a;
}

lapply3.R

lapply(a, add)  
#apply.Ajouter pour tous les éléments de a comme dans R()Postulez, mais
#L'apparence du résultat de sortie est appliquée.C'est totalement différent de R. Veuillez exécuter et vérifier

Remarque -Dans lapply3.java, Map <String, Integer> est utilisé comme type de retour, mais en réalité, le nombre de 1 à 16 (cast en type String) est entré dans Key, il semble donc redondant. Étant donné que le numéro de ligne et le numéro de colonne de la matrice R peuvent avoir des noms, une telle description est utilisée car la valeur entrée dans la clé peut ne pas être une valeur numérique lorsque vous essayez de correspondre exactement.

Traitement des chaînes

Dans l'ensemble, R n'est pas bon pour le traitement des chaînes de caractères. Si une grande quantité de traitement de chaînes de caractères est nécessaire pour le prétraitement des données, nous aimerions envisager d'utiliser un autre langage ou d'utiliser d'abord un logiciel de calcul de table.

Mise en relation

str_concat.java

//Exemple 1
String str = "Hello" + " " + "world!";  //Non recommandé car il consomme beaucoup de mémoire

//Exemple 2
StringBuilder builder = new StringBuilder();
builder.append("Hello");
builder.append(" ");
builder.append("world!");
String str = builder.toString();

str_concat.R

str <- paste("Hello", " ", "world!")

Dispositions complémentaires

Environnement d'exécution du code dans cette page

Java -Java version: 1.8.0_231 -IDE: Intellij IDEA Community Edition 2019.2

R -R version: R x64 3.6.0 -IDE: R Studio 1.2.1335

Veuillez vous y référer si vous ne pouvez pas l'exécuter correctement.