Was würde passieren, wenn ich Java7 die ganze Zeit berühren und diesen Prozess plötzlich in einer anderen Sprache schreiben würde? Ich dachte, also werde ich einen Moment darüber nachdenken. Aus diesem Grund habe ich über die Verarbeitung von Arrays nachgedacht, die in Web-Apps üblich ist.
↓ Grenzen Sie die Liste von json oder map auf Alter> 25 ein und sortieren Sie sie nach Alter in aufsteigender Reihenfolge
[
{"age":25, "name": "adam"},
{"age":60, "name": "adamo"},
{"age":30, "name": "larry"}
]
In Python werden Funktionen höherer Ordnung durch integrierte Funktionen definiert. Während Sie schreiben, wird die Verschachtelung allmählich tiefer. Aus diesem Grund ist es schwer zu verstehen, welche Art von Array-Verarbeitung für was selbst mit einer solchen Quelle durchgeführt wird.
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']
)
Curry wird unter Verwendung von Partial durchgeführt, und eine Methodenkette wird unter Verwendung von Reduce durchgeführt. Es scheint nicht so, als würde es allein herauskommen, aber es kann besser sein, wenn die Auswertung durch Rückgabe einer Methode wie xrange verschoben werden kann.
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
)
einfach.
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)
Wenn Sie die Karte behalten, fehlt ihr die Sicherheit. Ich denke, es ist eine gute Idee, es am Anfang wieder in das Klassenarray zu setzen oder es in der Mitte abzubilden.
//Muster von Anfang an zu ändern
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)
//Muster auf dem Weg zu ändern
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)
Tatsächlich gab es eine Person, die eine solche Quelle schrieb. Es ist etwas einfacher zu verstehen, wenn Sie Kenntnisse über Guaven haben ... Ich habe es richtig geschrieben, und als ich es bemerkte, benutzte ich die Klasse. Die Anfrage unterscheidet sich von der von 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;
}
})
);
Es ist nicht zu leugnen, dass das Sortierteil etwas altmodisch ist. Die Definition der ersten Daten ist ziemlich ärgerlich. Welches ist der beste Weg?
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());
Als ich dies unterwegs in einem Objekt aufbewahrte, wurde es ziemlich einfach.
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());
Was ist passiert, weil ich nur so ein enges Ding gesehen habe? Es fühlt sich so an, aber zumindest dachte ich, es wäre besser, Java7 wegzuwerfen und auf Java8 zu aktualisieren.
Ich habe es diesmal nicht geschrieben, aber da es Java7 ist, kann ich, wenn ich normal mit dem Prozedurtyp fortfahre, nichts sagen, da der Code mit Nebenwirkungen auch bei dieser Art der Array-Verarbeitung geschrieben wird Es ist sehr attraktiv, Code-Konventionen mit API erstellen zu können.
Recommended Posts