Que se passerait-il si je continuais à toucher java7 tout le temps et que j'écrivais soudainement ce processus dans une autre langue? J'ai pensé, alors je vais y réfléchir un instant. C'est pourquoi j'ai pensé au traitement des tableaux, qui est courant dans les applications Web.
↓ Réduisez la liste des json ou de la carte à l'âge> 25, puis triez par âge dans l'ordre croissant
[
{"age":25, "name": "adam"},
{"age":60, "name": "adamo"},
{"age":30, "name": "larry"}
]
En python, les fonctions d'ordre supérieur sont définies par des fonctions intégrées, de sorte qu'au fur et à mesure que vous écrivez, l'imbrication devient progressivement plus profonde. Pour cette raison, il est difficile de comprendre quel type de traitement de tableau est effectué pour quoi, même avec une telle source.
users= [
{"name":"adam","age":25},
{"name":"adamo","age":60},
{"name":"larry","age":30}
]
sorted(
filter(lambda a: a['age']>25,
users
),
key=lambda a:a['age']
)
Le curry est réalisé en utilisant partiel et une chaîne de méthodes est réalisée en utilisant la réduction. Il ne semble pas que cela va sortir seul, mais il peut être préférable que l'évaluation puisse être reportée en renvoyant une méthode comme xrange.
from functools import partial
def chain(*args):
return reduce(lambda x,f:f(x), args)
filter25 = partial(filter, lambda a: a['age']>25)
sortbyage = partial(sorted, key=lambda a:a['age'])
users=[
{"name":"adam","age":25},
{"name":"adamo","age":60},
{"name":"larry","age":30}
]
chain(
users,
filter25,
sortbyage
)
Facile.
val users: List[Map[Symbol,String]] = List(
Map('age->"25", 'name->"adam"),
Map('age->"60", 'name->"adamo"),
Map('age->"30", 'name->"larry")
)
users.filter(n => n.get('age).get.toInt > 25)
.sortBy(_.get('age).get)
Si vous gardez la carte, elle manque de sécurité. Je pense que c'est une bonne idée de le remettre dans le tableau de classe au début ou de le mapper au milieu.
//Motif à changer depuis le début
val users: List[Person] = List(
new Person(25, "adam"),
new Person(60,"adamo"),
new Person(30,"larry")
)
users.filter(n => n.age > 25)
.sortBy(_.age)
//Motif à changer en cours de route
val users: List[Map[Symbol,String]] = List(
Map('age->"25", 'name->"adam"),
Map('age->"60", 'name->"adamo"),
Map('age->"30", 'name->"larry")
)
users.map(n => new Person(n('age).toInt, n('name)))
.filter(n => n.age > 25)
.sortBy(_.age)
En fait, il y avait une personne qui a écrit une telle source. C'est un peu plus facile à comprendre si vous avez des connaissances sur la goyave ... Je l'ai écrit correctement, donc quand je l'ai remarqué, j'ai utilisé la classe. La requête est différente de celle de python.
List<Map<String, String>> users = ImmutableList.of<Map<String, String>>(
ImmutableMap.of("name", "adam", "age", "25"),
ImmutableMap.of("name", "adamo", "age", "60"),
ImmutableMap.of("name", "larry", "age", "30")
);
FluentIterable
.from(users)
.transform(new Function<Map<String, String>, Person>(){
@Override
public Person apply(Map<String,String> map){
return new Person(map.get("name"), new Integer(map.get("age")));
}
})
.filter(new Predicate<Person>(){
@Override
public boolean apply(Person person){
return person.age > 25;
}
})
.toSortedImmutableList(Ordering.natural().onResultOf(
new Function<Person, Integer>(){
@Override
public Integer apply(Person person){
return person.age;
}
})
);
Il est indéniable que la partie de tri est un peu démodée. La définition des premières données est assez ennuyeuse. Quel est le meilleur moyen?
List users = Collections.unmodifiableList(Arrays.asList(
new HashMap<String, String>(){{put("age","25");put("name","adam");};},
new HashMap<String, String>(){{put("age","60");put("name","adamo");};},
new HashMap<String, String>(){{put("age","30");put("name","larry");};}
)
);
users.stream()
.filter(a -> new Integer(a.get("age")) > 25)
.sorted((o1, o2) -> new Integer(o1.get("age")).compareTo(new Integer(o2.get("age"))))
.collect(Collectors.toList());
Quand je l'ai stocké dans un objet en cours de route, c'est devenu assez simple.
List users= Collections.unmodifiableList(Arrays.asList(
new HashMap<String, String>(){{put("age","25");put("name","adam");};},
new HashMap<String, String>(){{put("age","60");put("name","adamo");};},
new HashMap<String, String>(){{put("age","30");put("name","larry");};}
)
)
users.stream()
.map(a -> new Person(new Integer(a.get("age")), a.get("name")))
.filter(a -> a.age > 25)
.sorted(comparing(Person::getAge))
.collect(Collectors.toList());
Que s'est-il passé parce que je n'ai vu qu'une chose aussi étroite? C'est comme ça, mais au moins j'ai pensé qu'il serait préférable de jeter java7 et de passer à java8.
Je ne l'ai pas écrit cette fois, mais comme c'est java7, si je procède normalement avec un type procédural, même avec ce genre de traitement de tableau, j'ai l'impression que je ne peux rien dire car le code avec des effets secondaires est écrit comme "J'écrirai ici aussi", donc le flux de java8 Il est très intéressant de pouvoir créer des conventions de code avec API.
Recommended Posts