স্কালা এবং জাভা কোডের নমুনাগুলি যেখানে স্কালা কোডটি সহজ দেখায় / কম লাইন থাকে?

Question 1

আমার স্কেলা এবং জাভা কোডের কয়েকটি কোডের নমুনা (এবং আমি তাদের সম্পর্কে সত্যই কৌতূহলপূর্ণ) চাই যা দেখায় যে স্কালার কোডটি আরও সহজ এবং সংক্ষিপ্ত এবং তারপর জাভাতে লেখা কোড (অবশ্যই উভয় নমুনা একই সমস্যার সমাধান করা উচিত)।

যদি "স্কালার এটি বিমূর্ত কারখানা, জাভাতে এটি আরও জটিল দেখাবে" এর মত মন্তব্যে যদি কেবল স্কালার নমুনা থাকে তবে এটি গ্রহণযোগ্যও is

ধন্যবাদ!

আমি গ্রহণযোগ্য এবং এই উত্তরগুলির বেশিরভাগটি পছন্দ করি

Question 2

আসুন স্ট্যাকারের উদাহরণটি উন্নত করি এবং স্কালার কেস ক্লাসগুলি ব্যবহার করি :

case class Person(firstName: String, lastName: String)

উপরের স্কালা শ্রেণিতে নীচের জাভা শ্রেণীর সমস্ত বৈশিষ্ট্য রয়েছে এবং আরও কিছু রয়েছে - উদাহরণস্বরূপ এটি প্যাটার্ন মেলানো সমর্থন করে (যা জাভাতে নেই)। স্কেলা ২.৮ নামযুক্ত এবং ডিফল্ট যুক্তি যুক্ত করে, যা কেস ক্লাসগুলির জন্য একটি অনুলিপি পদ্ধতি তৈরি করতে ব্যবহৃত হয় , যা নিম্নলিখিত জাভা শ্রেণীর * পদ্ধতিগুলির সাথে একই ক্ষমতা প্রদান করে।

public class Person implements Serializable {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public Person withFirstName(String firstName) {
        return new Person(firstName, lastName);
    }

    public Person withLastName(String lastName) {
        return new Person(firstName, lastName);
    }

    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Person person = (Person) o;
        if (firstName != null ? !firstName.equals(person.firstName) : person.firstName != null) {
            return false;
        }
        if (lastName != null ? !lastName.equals(person.lastName) : person.lastName != null) {
            return false;
        }
        return true;
    }

    public int hashCode() {
        int result = firstName != null ? firstName.hashCode() : 0;
        result = 31 * result + (lastName != null ? lastName.hashCode() : 0);
        return result;
    }

    public String toString() {
        return "Person(" + firstName + "," + lastName + ")";
    }
}

তারপরে, আমাদের ব্যবহারের (অবশ্যই) রয়েছে:

Person mr = new Person("Bob", "Dobbelina");
Person miss = new Person("Roberta", "MacSweeney");
Person mrs = miss.withLastName(mr.getLastName());

বিরুদ্ধে

val mr = Person("Bob", "Dobbelina")
val miss = Person("Roberta", "MacSweeney")
val mrs = miss copy (lastName = mr.lastName)

Question 3

আমি এটি একটি চিত্তাকর্ষক পেয়েছি

জাভা

public class Person {
    private final String firstName;
    private final String lastName;
    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
}

স্কলা

class Person(val firstName: String, val lastName: String)

পাশাপাশি এইগুলিও (পেষ্ট না করার জন্য দুঃখিত, আমি কোডটি চুরি করতে চাইনি)

Question 4

কার্য: কীওয়ার্ডগুলির একটি তালিকা (বইয়ের মতো) সূচকে একটি প্রোগ্রাম লিখুন।

ব্যাখ্যা:

ইনপুট: তালিকা <স্ট্রিং>
আউটপুট: মানচিত্র <চরিত্র, তালিকা <স্ট্রিং>>
মানচিত্রের কীটি 'এ' থেকে 'জেড'
মানচিত্রে প্রতিটি তালিকা বাছাই করা হয়।

জাভা:

import java.util.*;

class Main {
  public static void main(String[] args) {
    List<String> keywords = Arrays.asList("Apple", "Ananas", "Mango", "Banana", "Beer"); 
    Map<Character, List<String>> result = new HashMap<Character, List<String>>(); 
    for(String k : keywords) {   
      char firstChar = k.charAt(0);     
      if(!result.containsKey(firstChar)) {     
        result.put(firstChar, new  ArrayList<String>());   
      }     
      result.get(firstChar).add(k); 
    } 
    for(List<String> list : result.values()) {   
      Collections.sort(list); 
    }
    System.out.println(result);         
  }
}

স্কেল:

object Main extends App {
  val keywords = List("Apple", "Ananas", "Mango", "Banana", "Beer")
  val result = keywords.sorted.groupBy(_.head)
  println(result)
}

Question 5

কার্য:

আপনার peopleক্লাসের অবজেক্টের একটি তালিকা রয়েছে Personযা ক্ষেত্রগুলি nameএবং age। আপনার কাজটি এই তালিকাটিকে প্রথমে nameএবং তারপরে বাছাই করা age।

জাভা 7:

Collections.sort(people, new Comparator<Person>() {
  public int compare(Person a, Person b) {
    return a.getName().compare(b.getName());
  }
});
Collections.sort(people, new Comparator<Person>() {
  public int compare(Person a, Person b) {
    return Integer.valueOf(a.getAge()).compare(b.getAge());
  }
});

স্কেল:

val sortedPeople = people.sortBy(p => (p.name, p.age))

হালনাগাদ

যেহেতু আমি এই উত্তরটি লিখেছি, বেশ কিছুটা অগ্রগতি হয়েছে। ল্যাম্বডাস (এবং পদ্ধতির উল্লেখগুলি) অবশেষে জাভাতে অবতরণ করেছে এবং তারা ঝড়ের দ্বারা জাভা বিশ্বকে নিয়ে যাচ্ছে।

উপরের কোডটি জাভা 8 এর সাথে দেখতে (যা ফ্রেডওভারফ্লো দ্বারা অবদান রেখেছেন) এর মতো হবে:

people.sort(Comparator.comparing(Person::getName).thenComparing(Person::getAge));

যদিও এই কোডটি প্রায় সংক্ষিপ্ত, এটি স্কালাল কোডের মতো পুরো মার্জিতভাবে কাজ করে না।

Scala সমাধান ইন, Seq[A]#sortByপদ্ধতি একটি ফাংশন গ্রহণ A => Bযেখানে Bপ্রয়োজন বোধ করা হয় আছে একটি Ordering। Orderingএকটি টাইপ-ক্লাস। উভয় জগতের সেরা চিন্তা করুন: যেমন Comparable, এটি প্রশ্নের ধরণের জন্য অন্তর্নিহিত, তবে Comparatorএটির মতো এটি এক্সটেনসিবল এবং প্রবণতা অনুসারে এটি যুক্ত না করে এমন সংখ্যায় যুক্ত হতে পারে। যেহেতু জাভাতে টাইপ-ক্লাসের অভাব রয়েছে, তাই এ জাতীয় প্রতিটি পদ্ধতির নকল করতে হবে, একবারের জন্য Comparable, তারপরেও Comparator। উদাহরণস্বরূপ, দেখুন comparingএবং thenComparing এখানে ।

টাইপ-ক্লাসগুলি একজনকে এমন নিয়ম লেখার অনুমতি দেয় যেমন "যদি A এর অর্ডার থাকে এবং B এর অর্ডার থাকে তবে তাদের টিপল (A, B) এরও অর্ডার থাকে"। কোডে, এটি হ'ল:

implicit def pairOrdering[A : Ordering, B : Ordering]: Ordering[(A, B)] = // impl

আমাদের কোডটিতে এইভাবে sortByনাম অনুসারে এবং তারপরে বয়সের সাথে তুলনা করা যায়। এই শব্দার্থকগুলি উপরের "বিধি" দিয়ে এনকোড করা হবে। একটি স্কালা প্রোগ্রামার স্বজ্ঞাতভাবে এইভাবে এটি কাজ করবে বলে আশা করবে। এর মতো কোনও বিশেষ উদ্দেশ্য পদ্ধতি comparingযুক্ত করা হয়নিOrdering ।

লাম্বডাস এবং পদ্ধতির উল্লেখগুলি হ'ল আইসবার্গের একটি টিপ যা কার্যকরী প্রোগ্রামিং। :)

Question 6

কার্য:

আপনার কাছে এমন একটি এক্সএমএল ফাইল "Company.xML" পাওয়া গেছে যা দেখতে দেখতে:

<?xml version="1.0"?>
<company>
    <employee>
        <firstname>Tom</firstname>
        <lastname>Cruise</lastname>
    </employee>
    <employee>
        <firstname>Paul</firstname>
        <lastname>Enderson</lastname>
    </employee>
    <employee>
        <firstname>George</firstname>
        <lastname>Bush</lastname>
    </employee>
</company>

আপনাকে এই ফাইলটি পড়তে হবে এবং সমস্ত কর্মচারীর ক্ষেত্র firstNameএবং lastNameক্ষেত্রগুলি মুদ্রণ করতে হবে।

জাভা: [ এখান থেকে তোলা ]

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XmlReader {
  public static void main(String[] args) {   
    try {
      File file = new File("company.xml");
      DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
      DocumentBuilder db = dbf.newDocumentBuilder();
      Document doc = db.parse(file);
      doc.getDocumentElement().normalize();
      NodeList nodeLst = doc.getElementsByTagName("employee");
      for (int s = 0; s < nodeLst.getLength(); s++) {  
        Node fstNode = nodeLst.item(s); 
        if (fstNode.getNodeType() == Node.ELEMENT_NODE) {         
          Element fstElmnt = (Element) fstNode;
          NodeList fstNmElmntLst = fstElmnt.getElementsByTagName("firstname");
          Element fstNmElmnt = (Element) fstNmElmntLst.item(0);
          NodeList fstNm = fstNmElmnt.getChildNodes();
          System.out.println("First Name: "  + ((Node) fstNm.item(0)).getNodeValue());
          NodeList lstNmElmntLst = fstElmnt.getElementsByTagName("lastname");
          Element lstNmElmnt = (Element) lstNmElmntLst.item(0);
          NodeList lstNm = lstNmElmnt.getChildNodes();
          System.out.println("Last Name: " + ((Node) lstNm.item(0)).getNodeValue());
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

স্কেলা: [ এখান থেকে নেওয়া , # 19 স্লাইড]

import xml.XML

object XmlReader {
  def main(args: Array[String]): Unit = {
    XML.loadFile("company.xml") match {
      case <employee> { employees @ _* } </employee> => {
        for(e <- employees) {
          println("First Name: " + (e \ "firstname").text)
          println("Last Name: " + (e \ "lastname").text)
        } 
      }
    }
  }
}

[বিল দ্বারা সম্পাদনা; আলোচনার জন্য মন্তব্যগুলি পরীক্ষা করুন] -

হুঁ, কোনও ফর্ম্যাট করে দেওয়া উত্তর বিভাগে জবাব না দিয়ে কীভাবে এটি করবেন ... এইচএমএইচএইচ। আমার ধারণা আমি আপনার উত্তরটি সম্পাদনা করব এবং এটি আপনাকে বাগ দিলে আপনাকে এটিকে মুছে ফেলতে দেব।

এইভাবে আমি জাভাতে আরও ভাল লাইব্রেরি সহ এটি করব:

public scanForEmployees(String filename) {
    GoodXMLLib source=new GoodXMLLib(filename);
    while( String[] employee: source.scanFor("employee", "firstname", "lastname") )
    {
          System.out.println("First Name: " + employee[0]);
          System.out.println("Last Name: " + employee[1]);
    }
}

এটি কোনও দ্রুত যাদু এবং সমস্ত পুনরায় ব্যবহারযোগ্য উপাদান জড়িত একটি দ্রুত হ্যাক। যদি আমি কিছু যাদু যুক্ত করতে চাইতাম তবে আমি স্ট্রিং অ্যারেগুলির অ্যারে ফিরিয়ে দেওয়ার চেয়ে আরও ভাল কিছু করতে পারতাম, তবে এই গুডএক্সএমএমএলিব সম্পূর্ণরূপে পুনরায় ব্যবহারযোগ্য হবে। স্ক্যানফোর্ডের প্রথম পরামিতিটি বিভাগটি, ভবিষ্যতের সমস্ত পরামিতিগুলি সীমিত যা সন্ধান করার জন্য আইটেমগুলি হবে, তবে কোনও সত্যিকারের সমস্যা ছাড়াই একাধিক স্তরের মিলের ইন্টারফেসটি সামান্য বাফ করা যেতে পারে।

আমি স্বীকার করব যে জাভাতে সাধারণভাবে বেশ দুর্বল গ্রন্থাগার সমর্থন রয়েছে তবে আসুন - জাভা দশকের (?) পুরাতন এক্সএমএল লাইব্রেরির ভয়াবহ ব্যবহারের সাথে তুলনা করার জন্য সংশ্লেষের ভিত্তিতে করা একটি বাস্তবায়ন কেবল ন্যায্য নয় - এবং দূরের কথা ভাষার তুলনা থেকে!

Question 7

স্ট্রিংয়ের উপর নির্ভর করে সম্পাদনের জন্য ক্রিয়াকলাপের মানচিত্র।

জাভা 7:

// strategy pattern = syntactic cruft resulting from lack of closures
public interface Todo {   
  public void perform();
}

final Map<String, Todo> todos = new HashMap<String,Todo>();
todos.put("hi", new Todo() { 
    public void perform() { 
        System.out.println("Good morning!");
    } 
} );

final Todo todo = todos.get("hi");
if (todo != null)
    todo.perform();
else
    System.out.println("task not found");

স্কেল:

val todos = Map( "hi" -> { () => println("Good morning!") } )
val defaultFun = () => println("task not found")
todos.getOrElse("hi", defaultFun).apply()

এবং এটি সব সম্ভব সেরা স্বাদে সম্পন্ন হয়েছে!

জাভা 8:

Map<String, Runnable> todos = new HashMap<>();
todos.put("hi", () -> System.out.println("Good morning!"));
Runnable defaultFun = () -> System.out.println("task not found");
todos.getOrDefault("hi", defaultFun).run();

Question 8

ডেভিড পোলকের 'বিগনিং স্কালা' বই থেকে নেওয়া বাছাই এবং রূপান্তরকরণের এই সহজ উদাহরণটি আমি পছন্দ করেছি:

স্কালায়:

def validByAge(in: List[Person]) = in.filter(_.valid).sortBy(_.age).map(_.first)
case class Person(val first: String, val last: String, val age: Int) {def valid: Boolean = age > 18}
validByAge(List(Person("John", "Valid", 32), Person("John", "Invalid", 17), Person("OtherJohn", "Valid", 19)))

জাভাতে:

public static List<String> validByAge(List<Person> in) {
   List<Person> people = new ArrayList<Person>();
   for (Person p: in) {
     if (p.valid()) people.add(p);
   }
   Collections.sort(people, new Comparator<Person>() {
      public int compare(Person a, Person b) {
        return a.age() - b.age();
      } 
   } );
   List<String> ret = new ArrayList<String>();
     for (Person p: people) {
       ret.add(p.first);
     }
   return ret;
}

public class Person {
    private final String firstName;
    private final String lastName;
    private final Integer age;
    public Person(String firstName, String lastName, Integer age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }
    public String getFirst() {
        return firstName;
    }
    public String getLast() {
        return lastName;
    }
    public Integer getAge() {
       return age;
    }
    public Boolean valid() {
       return age > 18;
    }
}

List<Person> input = new ArrayList<Person>();
input.add(new Person("John", "Valid", 32));
input.add(new Person("John", "InValid", 17));
input.add(new Person("OtherJohn", "Valid", 19));

List<Person> output = validByAge(input)

Question 9

আমি এখন স্কালায় একটি ব্ল্যাকজ্যাক গেম লিখছি। এখানে আমার ডিলারবিন্স পদ্ধতি জাভাতে দেখতে পাবেন:

boolean dealerWins() {
    for(Player player : players)
        if (player.beats(dealer))
            return false;
    return true;
}

এটি স্কালায় কেমন দেখাচ্ছে তা এখানে:

def dealerWins = !(players.exists(_.beats(dealer)))

উচ্চতর অর্ডার ফাংশন জন্য হুর!

জাভা 8 সমাধান:

boolean dealerWins() {
    return players.stream().noneMatch(player -> player.beats(dealer));
}

Question 10

কীভাবে কুইকসোর্ট?

জাভা

নীচে গুগল অনুসন্ধানের মাধ্যমে পাওয়া একটি জাভা উদাহরণ রয়েছে,

ইউআরএল হ'ল http://www.mycstutorials.com/articles/sorting/quicksort

public void quickSort(int array[]) 
// pre: array is full, all elements are non-null integers
// post: the array is sorted in ascending order
{
   quickSort(array, 0, array.length - 1);   // quicksort all the elements in the array
}


public void quickSort(int array[], int start, int end)
{
   int i = start;      // index of left-to-right scan
   int k = end;        // index of right-to-left scan

   if (end - start >= 1)               // check that there are at least two elements to sort
   {
       int pivot = array[start];       // set the pivot as the first element in the partition

       while (k > i)                   // while the scan indices from left and right have not met,
       {
           while (array[i] <= pivot && i <= end && k > i) // from the left, look for the first
              i++;                                        // element greater than the pivot
           while (array[k] > pivot && k >= start && k >= i) // from the right, look for the first
              k--;                                          // element not greater than the pivot
           if (k > i)                  // if the left seekindex is still smaller than
               swap(array, i, k);      // the right index, swap the corresponding elements
       }
       swap(array, start, k);          // after the indices have crossed, swap the last element in
                                       // the left partition with the pivot 
       quickSort(array, start, k - 1); // quicksort the left partition
       quickSort(array, k + 1, end);   // quicksort the right partition
    }
    else // if there is only one element in the partition, do not do any sorting
    {
        return;                        // the array is sorted, so exit
    }
}

public void swap(int array[], int index1, int index2) 
// pre: array is full and index1, index2 < array.length
// post: the values at indices 1 and 2 have been swapped
{
   int temp      = array[index1];      // store the first value in a temp
   array[index1] = array[index2];      // copy the value of the second into the first
   array[index2] = temp;               // copy the value of the temp into the second
}

স্কলা

একটি স্কেলা সংস্করণে একটি দ্রুত প্রচেষ্টা। কোড ইম্প্রুভারগুলির জন্য উন্মুক্ত মরসুম; @)

def qsort(l: List[Int]): List[Int] = {
  l match {
    case Nil         => Nil
    case pivot::tail => qsort(tail.filter(_ < pivot)) ::: pivot :: qsort(tail.filter(_ >= pivot))
  }
}

Question 11

আমি ব্যবহারকারীর অজানা এর উত্তর এত পছন্দ করেছি আমি এটির উন্নতি করার চেষ্টা করতে যাচ্ছি। নীচের কোডটি জাভা উদাহরণের সরাসরি অনুবাদ নয় , তবে একই API এর সাথে একই কাজটি সম্পাদন করে।

def wordCount (sc: Scanner, delimiter: String) = {
  val it = new Iterator[String] {
    def next = sc.nextLine()
    def hasNext = sc.hasNextLine()
  }
  val words = it flatMap (_ split delimiter iterator)
  words.toTraversable groupBy identity mapValues (_.size)
}

Question 12

আমি মিউটেবল্যাপে পাওয়া যায় এবং এখানে প্রথম দেখানো হয়েছে, প্রথমে জাভা ছাড়াই পাওয়া ওআরএলসআপডেট পদ্ধতিটি পছন্দ করি:

public static Map <String, Integer> wordCount (Scanner sc, String delimiters) {
    Map <String, Integer> dict = new HashMap <String, Integer> ();
            while (sc.hasNextLine ()) {
                    String[] words = sc.nextLine ().split (delimiters);
                    for (String word: words) {
                        if (dict.containsKey (word)) {
                            int count = dict.get (word);
                            dict.put (word, count + 1);
                        } else
                            dict.put (word, 1);
                    }
            }       
    return dict;
}

হ্যাঁ - একটি ওয়ার্ডকাউন্ট এবং এখানে স্ক্যালায়:

def wordCount (sc: Scanner, delimiter: String) = {
        val dict = new scala.collection.mutable.HashMap [String, Int]()
        while (sc.hasNextLine ()) {
                val words = sc.nextLine.split (delimiter)
                words.foreach (word =>
                      dict.update (word, dict.getOrElseUpdate (word, 0) + 1))
        }
        dict
}

এবং এটি জাভা 8 এ রয়েছে:

public static Map<String, Integer> wordCount(Scanner sc, String delimiters)
{
    Map<String, Integer> dict = new HashMap<>();
    while (sc.hasNextLine())
    {
        String[] words = sc.nextLine().split(delimiters);
        Stream.of(words).forEach(word -> dict.merge(word, 1, Integer::sum));
    }
    return dict;
}

এবং আপনি যদি 100% কার্যক্ষম যেতে চান:

import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;

public static Map<String, Long> wordCount(Scanner sc, String delimiters)
{
    Stream<String> stream = stream(sc.useDelimiter(delimiters));
    return stream.collect(groupingBy(identity(), counting()));
}

public static <T> Stream<T> stream(Iterator<T> iterator)
{
    Spliterator<T> spliterator = Spliterators.spliteratorUnknownSize(iterator, 0);
    return StreamSupport.stream(spliterator, false);
}

filterএবং sortইতিমধ্যে প্রদর্শিত হয়েছে, তবে তারা মানচিত্রের সাথে একীভূত করা কত সহজ:

    def filterKeywords (sc: Scanner, keywords: List[String]) = {
            val dict = wordCount (sc, "[^A-Za-z]")
            dict.filter (e => keywords.contains (e._1)).toList . sort (_._2 < _._2)
    }

Question 13

এটি খুব সহজ উদাহরণ: স্কোয়ার পূর্ণসংখ্যা এবং তারপরে সেগুলি যুক্ত করুন


    public int sumSquare(int[] list) {
        int s = 0;
        for(int i = 0; i < list.length; i++) {
            s += list[i] * list[i]; 
        }
        return s;
    }

স্কেলে:


val ar = Array(1,2,3)
def square(x:Int) = x * x
def add(s:Int,i:Int) = s+i

ar.map(square).foldLeft(0)(add)

কমপ্যাক্ট মানচিত্র অ্যারের সমস্ত উপাদানগুলিতে ফাংশনটি প্রয়োগ করে, তাই:

Array(1,2,3).map(square)
Array[Int] = Array(1, 4, 9)

ভাঁজ বামটি 0 দিয়ে শুরু হবে সঞ্চালক (গুলি) হিসাবে এবং add(s,i)অ্যারের সমস্ত উপাদানগুলিতে (i) প্রয়োগ হবে, যাতে:

 Array(1,4,9).foldLeft(0)(add)  // return 14 form 0 + 1 + 4 + 9

এখন এটি আরও সংক্ষিপ্ত করা যেতে পারে:

Array(1,2,3).map(x => x * x ).foldLeft(0)((s,i) => s + i )

এটি আমি জাভাতে চেষ্টা করব না (অনেক কাজ করার জন্য), এক্সএমএলটিকে মানচিত্রে পরিণত করুন:


<a>
   <b id="a10">Scala</b>
   <b id="b20">rules</b>
</a>

এক্সএমএল থেকে মানচিত্রটি পেতে অন্য একটি লাইনার:


val xml = <a><b id="a10">Scala</b><b id="b20">rules</b></a>

val map = xml.child.map( n => (n \ "@id").text -> n.child.text).toMap
// Just to dump it.
for( (k,v) <- map) println(k + " --> " + v)

Question 14

সমস্যা: আপনাকে এমন একটি পদ্ধতি ডিজাইন করতে হবে যা প্রদত্ত যে কোনও কোডকে অবিচ্ছিন্নভাবে কার্যকর করবে। জাভাতে

সমাধান :

/**
* This method fires runnables asynchronously
*/
void execAsync(Runnable runnable){
    Executor executor = new Executor() {
        public void execute(Runnable r) {
            new Thread(r).start();
        }
    };
    executor.execute(runnable);
}

...

execAsync(new Runnable() {
            public void run() {
                ...   // put here the code, that need to be executed asynchronously
            }
});

স্কালায় একই জিনিস (অভিনেতা ব্যবহার করে):

def execAsync(body: => Unit): Unit = {
  case object ExecAsync    
  actor {
    start; this ! ExecAsync
    loop {
      react {           
        case ExecAsync => body; stop
      }
    }
  }    
}

...

execAsync{  // expressive syntax - don't need to create anonymous classes
  ...  // put here the code, that need to be executed asynchronously    
}

Question 15

থেকে সার্কিট ব্রেকার প্যাটার্ন মাইকেল Nygard মুক্তির এটা মধ্যে FaKods ( কোডে লিংক )

বাস্তবায়ন স্কালায় এর মত দেখাচ্ছে:

. . .
addCircuitBreaker("test", CircuitBreakerConfiguration(100,10))
. . .


class Test extends UsingCircuitBreaker {
  def myMethodWorkingFine = {
    withCircuitBreaker("test") {
      . . .
    }
  }

  def myMethodDoingWrong = {
    withCircuitBreaker("test") {
      require(false,"FUBAR!!!")
    }
  }
}

যা আমি মনে করি দুর্দান্ত। এটি দেখতে কেবল ভাষার পাইস হিসাবে দেখায় তবে এটি সার্কিটব্রেকার অবজেক্টে সমস্ত কাজ করে এমন একটি সাধারণ মিশ্রণ ।

/**
 * Basic MixIn for using CircuitBreaker Scope method
 *
 * @author Christopher Schmidt
 */
trait UsingCircuitBreaker {
  def withCircuitBreaker[T](name: String)(f: => T): T = {
    CircuitBreaker(name).invoke(f)
  }
}

"সার্কিট ব্রেকার" + এর জন্য আপনার ভাষার জন্য অন্য ভাষাগুলির উল্লেখ।

Question 16

আমি একটি নথি প্রস্তুত করছি যা জাভা এবং স্কালা কোডের বেশ কয়েকটি উদাহরণ দেয়, কেবলমাত্র স্কালার বৈশিষ্ট্যগুলি বোঝার জন্য সহজ ব্যবহার করে:

স্কেলা: আরও ভাল জাভা

আপনি যদি আমাকে এটিতে কিছু যুক্ত করতে চান তবে মন্তব্যে উত্তর দিন।

Question 17

অবিরাম প্রবাহের অলসতার মূল্যায়ন এর একটি ভাল উদাহরণ:

object Main extends Application {

   def from(n: Int): Stream[Int] = Stream.cons(n, from(n + 1))

   def sieve(s: Stream[Int]): Stream[Int] =
     Stream.cons(s.head, sieve(s.tail filter { _ % s.head != 0 }))

   def primes = sieve(from(2))

   primes take 10 print

}

এখানে জাভাতে অসীম স্ট্রিমগুলিকে সম্বোধন করার একটি প্রশ্ন রয়েছে: অসীম পুনরাবৃত্তি কি খারাপ নকশা?

আর একটি ভাল উদাহরণ প্রথম শ্রেণির ফাংশন এবং ক্লোজারগুলি:

scala> def f1(w:Double) = (d:Double) => math.sin(d) * w
f1: (w: Double)(Double) => Double

scala> def f2(w:Double, q:Double) = (d:Double) => d * q * w
f2: (w: Double,q: Double)(Double) => Double

scala> val l = List(f1(3.0), f2(4.0, 0.5))
l: List[(Double) => Double] = List(<function1>, <function1>)

scala> l.map(_(2))
res0: List[Double] = List(2.727892280477045, 4.0)

জাভা প্রথম শ্রেণীর ফাংশন সমর্থন করে না, এবং বেনামে অভ্যন্তর শ্রেণীর সাথে বন্ধগুলি নকল করা খুব মার্জিত নয়। এই উদাহরণটি দেখায় যে আরও একটি জিনিস জাভা করতে পারে না তা হ'ল দোভাষী / রিপিএল থেকে কোড চালানো। কোড স্নিপেটগুলি দ্রুত পরীক্ষার জন্য আমি এটি অত্যন্ত দরকারী বলে মনে করি।

Question 18

কেন আগে কেউ এ পোস্ট করেনি:

জাভা:

class Hello {
     public static void main( String [] args ) {
          System.out.println("Hello world");
     }
}

116 টি অক্ষর।

স্কেল:

object Hello extends App {
     println("Hello world")
}

56 টি অক্ষর।

Question 19

এই স্কালা কোড ...

def partition[T](items: List[T], p: (T, T) => Boolean): List[List[T]] = {
  items.foldRight[List[List[T]]](Nil)((item: T, items: List[List[T]]) => items match {
    case (first :: rest) :: last if p (first, item) =>
      (List(item)) :: (first :: rest) :: last
    case (first :: rest) :: last =>
      (item :: first :: rest) :: last
    case _ => List(List(item))
  })
}

... জাভাতে পুরোপুরি অপঠনযোগ্য, যদি সম্ভব হয় তবে তা সম্ভব।