Expressiveness, conciseness and behavior

coll_adv.java

// User:: Long id, String name, Gender gender, Integer age
List<User> users = new ArrayList<>();
user.add(new User(0, "a", Gender.Female, 15));
user.add(new User(1, "b", Gender.Male,   18));
user.add(new User(2, "c", Gender.Male,   21));
user.add(new User(3, "d", Gender.Female, 24));
user.add(new User(4, "e", Gender.Female, 27));
user.add(new User(5, "f", Gender.Male,   30));
List<Long> result = new ArrayList<>();
int take = ???;
// Example 1
for (User u : users) {
  if (take == 0) {
    break;
  }
  if (user.getGender() == Gender.Female) {
    result.add(user.getId());
    take--;
  }
}  
// Example 2
for (Iterator<User> i = users.iterator(); i.hasNext() && take != 0 ; ) {
  User user = i.next();
  if (user.getGender() == Gender.Female) {
    result.add(user.getId());
    take--;
  }
} 

coll_adv8.java

// User:: Long id, String name, Gender gender, Integer age
List<User> users = new ArrayList<>();
user.add(new User(0, "a", Gender.Female, 15));
user.add(new User(1, "b", Gender.Male,   18));
user.add(new User(2, "c", Gender.Male,   21));
user.add(new User(3, "d", Gender.Female, 24));
user.add(new User(4, "e", Gender.Female, 27));
user.add(new User(5, "f", Gender.Male,   30));

//Example 1
users .stream()                      // noise
      .filter(user -> user.getGender() == Gender.Female)
      .map(user -> user.getId())
      .limit(2)
      .collect(Collectors.toList()); // noise
      
      
// Example 2
class Test {
  public static Boolean userFilter(User user) { user.getGender() == Gender.Female; }
}
int take = 2;
users .stream()
      .filter(Test::userFilter) 
      .map(user -> user.getId())
      .limit(take)
      .collect(Collectors.toList());

coll_simple.java

// Java 1.4
List users = new ArrayList();
user.add(new User("a"));
user.add(new User("b"));
User u = null;
List names = new ArrayList();
for (Iterator i = users.iterator(); i.hasNext(); ) {
  Object o = i.next();
  if (o instanceof User) {
    names.add(((User)o).getName());
  }
}

// Java 1.5
List<User> users = new ArrayList<User>();
user.add(new User("a"));
user.add(new User("b"));
List<String> names = new ArrayList<String>();
for (User u : users) {
  names.add(u.getName());
}

// Java 1.7
List<User> users = new ArrayList<>(); //really?...
user.add(new User("a"));
user.add(new User("b"));
List<String> names = new ArrayList<>();
for (User u : users) {
  names.add(u.getName());
}

// Java 1.8
List<User> users = new ArrayList<>(); //really?...
user.add(new User("a"));
user.add(new User("b"));
List<String> names = users.map(x -> x.getName())

for.scala

val graph = for {
              u <- users
              v <- users if u != v
              r <- relations(u, v)
            } yield (u, v, r)

for {
  (u, v, r) <- graph
  target    <- broadcastTargets(u)
} target.send(v, r)
// without a yield, a for will return Unit => not void!

futures.scala

// fetch : Long => Future[User]
val fut = for {
            u       <- fetch(userId)
            friends <- Futures.sequence(u.friendsIds.map(fId => fetch(fId)))
          } yield (u, friends)

fut .map{ case (u, fs) => (u, fs.size) }
    .onSuccess(userWithFriends => 
      println(s"User $userWithFriends._1 has $userWithFriends._2 friends")
    )

implicit.scala

class Test {
  implicit val session = DBSession.create
  //...
  def testPersist = {
     val user = User()
     persist(user)         //See? `session` is not passed in!
  }
}

MRTweet.scala

val l:List[A] 
val m[K,V]:A=>List[(K, V)] 
val r[V]:List[V]=>V 
val s[K]:K=>K

l .flatMap(m)
  .groupBy(_._1) // map phase
  .mapValues(_.map(_._2))
    .groupBy{case (x, xs) => s(x) } // shuffled
    .mapValues(_.map{case (x,xs) => (x, r(xs))}) // reduced
      .values
      .flatten // aggregate

readableMR.scala

val data:List[A] 
val mapper[K,V]:A=>List[(K, V)] 
val reducer[V]:List[V]=>V 
val shuffler[K]:K=>K //hash

// MAP Phase
val tempMappedData:Map[K, (K,List[V])]    = data.flatMap(m).groupBy(_._1)  // this is a classical good use of _
//the easy part that can be parallelized 
val mappedData:Map[K, List[V]]            = tempMappedData.mapValues(vs => vs.map(_._2)) // same use of _

// SHUFFLE Phase
val shuffledData:Map[K, Map[K, List[V]]]  = mappedData.groupBy{case (v, vs) => shuffler(v) }

//REDUCE Phase
//the hard part that can be parallelized 
val tempReducedData:Map[K, Map[K, V]]     = shuffledData.mapValues{ oneMachineMap => 
                                              oneMachineMap.map{ case (v,vs) => 
                                                (v, reducer(vs))
                                              }
                                            }
                                            
// AGGREGATION Phase... not really needed by MR
val reducedData:Map[K, V]                 = tempReducedData.values.flatten