Git log with names of branches and tags

As default git log doesn’t give you information about branches and tags. If you need such info you must add –decorate argument to git log command, for example:

$ git log --oneline --decorate  
9bfa493 (HEAD, origin/1.3.x, r, 1.3.x) [#1581] Close input field for authenticityToken
ef811e8 [#1577] Remove e.printStackTrace()
6359253 [#1570] Allow setting of SSL ciphers as configuration option
89f1deb remove dead code
d795bee Hide language menu on module page
601ead1 [#1493] docviewer cosmetic changes
637f33a Fixed wrong declaration of jquery version
76a624d Fixed wrong version of jquery
d1b66e4 [#1493] Done on i18n of docviewer
6d4ee8e Merge pull request #512 from xael-fry/lighthouse-1524-patch

Autotracking remote branch when pushing

What is tracking? Tracking is a link between a local and remote branch. If you trackremote branch you can use git pull and git push without any extra arguments and git will know what to do.

You just add -u parameter when pushing to do this

$ git push -u origin master
Branch master set up to track remote branch master from origin.

However, git push pushes all branches that have the same name on the remote. you can limit this behavior to just the current branch. You need to set configuration:

$ git config --global push.default tracking

Configuration entry above prevent accidental pushing into branches which you’re not ready push yet.

Tracking remote branch that you haven’t it already in local

If in the remote repository is branch, that you haven’t on local already. You can easy push it with tracking option:

$ git checkout -t origin/develop

In this case you make local branch develop from the remote repo with tracking option.

Fetch few branches at once

You can change your default behavior that fetch commits from remotes. For instance you can define list of remotes to be fetched by the remote update command. You have to change you config a little, for instance if you want fetch origin, and staging branches at once, you need:

$ git config remotes.default 'origin staging'
$ git remote update

You can also group remotes to simplify commands.

$ git config remotes.my_group 'remoteA remoteB'
$ git update my_group

Finding branch which contains commit

Just use:

$ git branch --contains d94d164

This command filter the list of branches and display only those which have the given commit among their ancesors. It work also when you display all branches with -a parameter.

The cherry command

Cherry command is useful if you want to find changes from current branch which are already present upstream. Shorter – cherry is a command that find which commit was cherry-picked from one branch to another.

$ git cherry -v master

+ 48c0042b [#871] Locale for a request is now lazy resolved
- d2006c70 [#877] throw NPE with explanation when trying to resolve Message with '&' in template when key resolves to null
- 0404c3f9 [#904] Read play id from sytem properties in JUnitTestrunner

This command compares changes on the current branch to upstream („master”). If changes are present at both are marked with „-„, changes still missing from upstream are marked with „+”.

A little shorter status output

As default git use verbose status output. It’s fine for beginners, but if you feel more comfortable with git, you no need anymore all the info the verbose provide. You can use short status output instead.

$ git status -sb

## 1.3.x...origin/1.3.x
M framework/src/play/mvc/ActionInvoker.java

Find the commit by message text

You can find commit which message matches regexp pattern
For example if you want find the commit that was `fixme` in it message you should use command:

$ git show :/fixme

or find last merge commit:

$ git show :/^Merge

Highlight diff changes by words, not by lines

If you use --word-diff as argument for diff command, all changes will be displayed as words instead of lines.

$ git diff --w  ord-diff

Other commands that take diff flags can use this argumes as well. For instance: git log -p and git show.

Using references to checked out branches history

Git has a special syntax for checked out history.
@{-n} means „n-th branch checked out before current one”. When we checkout develop from master – @{-1} is reference to master branch. After rebasing, we need to use @{-2} to checkout master because @{-1} is a reference to the same branch.

Rename branch name

You can rename local branch name with command:

$ git branch -m current_name new_name

But what with the remote?

$ git push origin :old_name
$ git push origin new_name

But what about extremely rare situation where you need rename master branch. You need to use commands as follow:

#first change local name
$ git branch -m master master_old
#remote remote master branch
$ git push remote :master
#make master_old in remote
$ git push remote master_old
#make new master in local
$ git checkout -b master branch_you_make_new_master_from
#make master in remote
$ git push remote master

Add notes to commits

Git notes are annotations for existing commits. You can add notes to any existing commit without aware they don’t change the history. Notes are stored only in your repo, but there are few very interestign ideas how use them.

$ git notes add
#suddenly editor is opened and you need to edit the note!!!

.

For example:
We have trait with complex mwthod. This trait is mixed into used class. Problem: In few cases we want to change the functionality of the implemented method.

What to do?
We have to make another trait that will be changed with default one.

trait Debugger {
    def log(message: String): String
}

trait ADebugger extends Debugger {
    override def log(message: String) = {
        "A: "+message
    }
}

trait BDebugger extends Debugger {
    override def log(message: String) = {
        "B: "+message
    }
}    

class Logger extends Debugger with ADebugger

ADebugger is default trait.

val l1 = new Logger
val m = l.log("hello")
//m: String = A: hello

val l2 = new Logger with BDebugger    //We mixin another trait into instance!!
val m2 = l2.log("hello")
//m: String = B: hello

More to read:
http://www.artima.com/scalazine/articles/stackable_trait_pattern.html
.

Version 8 of the Java ME Embedded contains a different architecture than previous versions. With version 8, you have the option to run Developer agent on the desktop side under Windows. Commands that are sent to the board from Windows are no longer sent directly across the network. Instead, they are sent to the Developer agent, which transmits all comunication to and from Java ME Embedded executable on the Raspberry Pi board.

Raspberry Pi is the one choosen platform that Java ME Embedded is prepared for. Go to the download site where you can download Java for this board.

You can unpack this on local computer, you’ll need it later.

Further put the archive on the Raspberry Pi board (by scp or ftp) and unpack it where you want. Archive has four directories:
– /appdb contains internal Java libraries,
– /bin contains executables and the jwc_properties.ini file,
– /legal contains important legal documentation,
– /lib is needed only on the Windows, and contains the files needed to execute the Developer Agent on the desktop side.

I have unpacked it in the /opt/javame directory. Don’t forget to add execution rights files under appdb and bin:

chmod -R 777 appdb bin

Using Java Runtime on the Raspberry Pi

You can to this in few ways:
– You can execute commands directly at the rasbian shell,
– You can use Netbeans 8,
– You can use Developer Agent, started manually, and run commands using this tool.

/bin scripts

The /bin directory contains a set of sctript needed to run Java ME Embedded applications. What we can find:

• installMidlet.sh – script for installing new midlets,
• listMidlets.sh – show us list all installed IMlet suites and their statuses. If name of suite is used as parameter, its show the detail of this single suit.
• removeMidlet.sh – You know, what the script is for. It’ for uninstalling midlets.
• runSuite.sh is for executing installed, specified by argument Suite\Imlet (or the default if none is specified). All logging information appears in the stdout. This command should be prepend with sudo to ensure script has access to peripherals on the board.

The last one script I want to describe is usertest.sh. This script is for running Raspberry Pi in the server mode.

Server mode

In this mode you are able to run all above commands from remote machine. To be ensure the script obtain superuser privileges to access all the peripherals on the board, You have to run this script with sudo:

sudo ./usertest.sh

After this you can connect to AMS from remote machine.

Connecting to AMS from Windows.

Using console

Go to the directory when Java ME Embedded for Raspberry is unpacked. You can delete appdb and bin the directories aren’t needed in Windows. Go to the /lib and run command:

java -jar proxy.jar -socket IP_OF_YOUR_RASPBERRY

In the mode Application Management System must be already running.
If you want you can run proxy.jar in the Client mode, but check the documentation how to do this. Check the commands You can use within this connection at documentation too.

Using Developer agent

When you use Netbeans for developing Midlets you have also installed Java ME Embedded Emulator 8.0 tool. When you start this application you’ll get access to three default emulators to test your midlet against them. But you can add you raspberry to the list. Use tool that is loaded into system tray: Device Manager. Click Add button, set the IP of your raspberry Pi board and finish with OK button. You’ll see manager will connect to the board. From this time, Your real board (not emulator) can be used directly from Netbeans as a device you want to run your IMlet.

Have a fun!
.

Instalation is quite simple, what we need?:

From Java ME 8 SDK download page download:
– Latest build of platform,
– Plugins for Netbeans,
– Sample code if you want.
– We need also Netbeans at version 8 or better

I have prepared directory for all development tools : D:\devel

First step is optional, but I want to work most recent Java platform, and install Java 8 JDK at D:\devel\jdk8\. Java ME 8 SDK no need version 8 of Java, required version is Java 7 update 45 if I remember well.

Next we should set up two environment variables:
we should point JDK_DIR to the java installation directory, and add bin directory to the PATH.

add to the system variables:

JDK_DIR=D:\devel\jdk8

and add:

;%JDK_DIR%\bin

at the end PATH variable.

Next step is installig Java ME 8 SDK – just double click installer and check displayed instructions.
The same way we install Netbeans

Before we install netbeans plugins we should unpack downloaded archive with code. We unpacked it in the D:\devel\jme-sdk-8-plugins directory.

Now start the Netbeans IDE. Choose Tools -> Plugins from top menu to open plugins manager. We have to add our local plugins directory, then go to Settings tab.
Click Add button in the lower right. Now you should see the box with few fields. It’s Update Center Customizer in the title.
In the field name put anything you want. It’s name of the repository. I’ve used ‚Java ME 8 Local’. Select check for updates checkbox. In the last field (URL) write path to updates.xml file placed in the directory from archive above. On my computer it will be: file:/D:/devel/jme-sdk-8-plugins/updates.xml.
Click OK – it save all data.

If everything is OK, there should be available 2 more plugins at the Available Plugins tab: Java ME SDK Tools and Java ME SDK Demos. Choose Install checkbox for them, and click Install button. After accepting agreement, Finish the instalation.

Thats all. Now we can write our first Java Me 8 Midlet and test it on remote Raspberry PI computer!
.

Contraint programming is an emergent software technology for declarative description and effective solving of large, particularly combinatorial, problems especially in areas of planning and scheduling. It represents the most exciting developments in programming languages of the last decade and, not surprisingly, it has recently been identified by the ACM (Association for Computing Machinery) as one of the strategic directions in computer research.(source)

Since that day I use this type of programming very regular. As Java programmer best for me is Choco Solver library.
Choco’s current version is 3 but documentation is still in writing (since last summer at least) It’s sad. Developers starting with this tool has no documentation. You have option to choose version 2 (well documented), but both of them aren’t compatible and upgrade won’t be easy process.

The summary cheat is only documentation provided for 3rd version of tool.

Although Choco is worth of few minutes.

I’ll try write quick example how it works.

Resolving Sudoku grid with Choco

Sudoku is well known, I don’t write what is this. If you don’t know, just click link and read the wiki page :)

Our goal:

Write code that get the 9×9 grid as parameter with digits from 0-9 and change all 0 to digit from range 1-9. All digits in row, column and 3×3 sector should be different.

What we need? JDK1.6 and choco 3.1 library it’s a lot. To write code use your IDE or notepad, your will.

Start

We need object for our grid. We can use simple int[][] two dimensional array for it. But we wrap this array into Grid class for cleaning code (there’ll be a lot of arrays :))

public class Grid {

   final int[][] sudokuGrid;

   public Grid(int[][] grid){
       this.sudokuGrid = grid;
   }

   public int get(int i, int j){
       return sudokuGrid[i][j];
   }
}

Our helper is ready. Time to write Sudoku solver.

What field we need?
first will be width of grid, Sudoku’s use 9×9 grid, but if you want to resolve any bigger clone of this puzzle?

Another fields are arrays for rows, columns and sectors. All of them are 2 dimensional array 9×9

We use a smart code to retrieve 3×3 two-dimensional array and exchange it into one-dimensional 9-elements array for every sector. We should only check that all elements are different no matter what position they are at.

The another one is gridData provided as argument.
The last but most important is Solver model. Solver is central object that collect data and compute solution. Let’s see:

public class SudokuSolver {
  //we working on 9x9 grid
  final int n = 9; 

  IntVar[][] cols, rows, sectors;

  Grid gridData;
  Solver solver;

   public SudokuSolver(){
     solver = new Solver("Brilliant Sudoku Solver");
   }


}

Ok. That was easy, but what is IntVal? This is wrapper for Integer value. We can set is as fixed value or as need to be computed value. In fact computing this values is our main goal.

Maybe we should start from this, but it’s time to think about alogithm. It’s pretty clean and simple. Invoke solver, set grid to resolve and resolve it.

Algorithm is made, than we can implement it. I won’t use Test classes or any other external tool, just include my own test code into main method to simplify the code.

public static void main(String[] args) {
    System.out.println("We'll resolve sudoku puzzle now!");

     SudokuSolver sudokuSolver = new SudokuSolver();
     //set data
     sudokuSolver.setGridData(new Grid(new int[][]{
             {0, 0, 0, 2, 0, 0, 0, 0, 0},
            {0, 8, 0, 0, 3, 0, 0, 7, 0},
            {3, 0, 0, 5, 0, 4, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 2, 8},
            {8, 3, 0, 0, 1, 0, 0, 0, 0},
            {0, 4, 0, 7, 2, 0, 3, 5, 1},
            {0, 7, 0, 0, 5, 6, 0, 0, 4},
            {0, 0, 3, 0, 0, 0, 0, 0, 0},
            {2, 0, 5, 4, 0, 1, 6, 0, 3}
      }));
      //solve it :)
      sudokuSolver.solve();

Now we have a little more code to write. Time to setting data.

public void setGridData(Grid gridData){

first set data to fields.

this.gridData = gridData;

//fill in arrays
rows = new IntVar[n][n];
cols = new IntVar[n][n];
sectors = new IntVar[n][n];

Next steps is filling rows and columns. To fill in rows, just iterate over two-dimensional grid, read seeded data and put elements into rows array: If origin value is within range 1-9 then just copy it, if it is 0 then tell Solver it should be computed in this place.

Filling in columns is made by copying value from rows array.

//fill rows and columns
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            //read values from data grid
            if (gridData.get(i, j) > 0) {
                //if value is over 0, it should be copied
                rows[i][j] = VariableFactory.fixed(gridData.get(i, j), solver);
            } else {
                //if value is 0, it should be computed
                rows[i][j] = VariableFactory.enumerated("c_" + i + "_" + j, 1, n, solver);//<- we will talk about it
            }
            //copy value to cols array
            cols[j][i] = rows[i][j];
        }
    }

I think almost all in code above is self explanatory. But two things needs few words.
VarableFactory is a class that compute variables. We use it 2 times. First time we use it for setting provided value with fixed method. Second time we use it to tell solver the value here should be computed. We use enumerated method that get minimum and maximum values and all possible computed values are returned from array :MIN, MIN+1, ... , MAX-1, MAX.First argument is string that represents name of computed variable. We used number of row and column prefixed by „c_”. Last argument in both cases is Solver object needed for computation.

Now the smart code for exchange sectors from 3×3 grid into 1×9 grid:

//compute sectors
    //Sudoku game has 9 sectors 3x3, to simplify we'll made 9 arrays with 9 elements, every array for 1 sector.
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 3; k++) {
                //iterate over every sector and copy values into arrays
                sectors[j + k * 3][i] = rows[k * 3][i + j * 3];
                sectors[j + k * 3][i + 3] = rows[1 + k * 3][i + j * 3];
                sectors[j + k * 3][i + 6] = rows[2 + k * 3][i + j * 3];
            }
        }
    }

We already have data set, now we need to make computations.

just write last one method solve():

First in we should define constrains:

Every row, column and sector should has different values. We have all data at 3 9×9 arrays.

Ok. Iterate over them and let’s set constraints.

for (int i = 0; i < 9; i++) {

     solver.post(IntConstraintFactory.alldifferent(rows[i], "AC"));
     solver.post(IntConstraintFactory.alldifferent(cols[i], "AC"));       
     solver.post(IntConstraintFactory.alldifferent(sectors[i], "AC"));

}

„AC” is algorithm we use for computation. We can use „AC”, „BC” or „DEFAULT”. First is faster, second is more precise, third is mix of both previous.

Now set up strategy:

solver.set(IntStrategyFactory.firstFail_InDomainMin(ArrayUtils.append(rows)));

Choco provides a lot of strategies just look into API. We’ve choosed Mix of firstFail and InDomainMin method. FirstFail will work at smallest domain data, InDomainMin will start from smallest possible value.

Now we have all done. Starting computation is made by calling findSolution method that give boolean value as return.

if (solver.findSolution()) {
      printIt();//pretty print the solution
 } else {
      System.out.println("No Solution!");
 }

Easy, isn’t it?

All code at gist:
Grid.java
SudokuSolver.java
.

Java 8 provide solution for problem of this kind – default methods.

Java designers decided to define methods with concrete implementations in interfaces. This methods are called default methods. Those methods can be safely added to existing interfaces.

Consider the interface:

public interface Person {

  public String getDisplayName();      

  default String getName(){
    return "Firstname: "+getClass().getSimpleName();
  }

}

The interface has two methods: the abstract one getDisplayName() and the default one getName() – a concrete class that implements the Person interface must provide an implementation of getDisplayName(), but it can choose to keep the implementation of getName() or to override it.

There is risk to implement two (or even more) interfaces with the same name of default method. What’s then?

For example:

public interface Animal {
  default String getName() {
    return "Animal name: "+getClass().getSimpleName();
  }
}

public class Werewolf implements Person, Animal {

  //implementation of getDisplayName() here 
}

But which default getName() compilator’ll choose? No one In such case you’ll get an error that class implements few unrelated default methods with the same name. You should override this method and add your own implementation.

If you prefer to choose implementation from interface you have to define it manually. Example below shows how to choose Person‚s default method.

public class Werewolf implements Person, Animal {

  public String getName(){
    return Person.super.getName();//we choose default implementation from Person interface
    //but in fact it should be depend on moon's phase :)
  }
}

Second case is when class implement interface with default method and extend superclass which implement another interface with method of the same name.
What’s then? It depends. Main rule is one: „class’ implementations always wins”. If superclass overrides the method, than subclass use the implemtation. If superclass doesn’t override but use default method from interface, then there is interface clash and this method should be overriden with its own implementation.

Static methods in interfaces

As of Java 8, you are allowed to add static methods to interfaces. Up to now, it has been common to place static methods in utility (companion) classes. In standard library you’ll find a lot of pairs such classes, for example: Array/Arrays, Collection/Collections or Path/Paths. Now you can all static methods put into interface class.
.

Sometimes, there is already a method that carries out exactly the action that you’d like to pass on to some other code. For example, suppose you simply want to print the event object whenever a button is clicked. You can use code below:

button.setOnAction(event -> System.out.println(event));

But there is simpler way to do it. If you want to just pass the println method to the setOnAction method you can use method references:

button.setOnAction(System.out::println);

This is equivalent to code above.

As you can see from these examples, the :: operator separates the method name from the name of an object or class. There are three principal classes:

• object::instanceMethod
• Class::staticMethod
• Class::instanceMethod

Two first cases works the same as in the example above. Method reference is equivalent to a lambda expression that supplies the parameters of the method.

System.out::println is equivalent to x -> System.out.println(x)

Similarly
Math::pow is equivalent to (x, y) -> Math.pow(x, y) as described at second case above.

The last one case is different from these above. The first parameter becomes the target of the method.

String::compareToIgnoreCase is the same as (x, y) -> x.compareToIgnoreCase(y)

You can use this and super keywords. this refer to an enclosing class.
You can treat it as follow:

EnclosingClass.this::method
EnclosingClass.super::method

Example:

Thread t = new Thread(super::doSomething());

Constructor references

You can use contructor references as well. It’s just like method references, except that the name of the method is new

Button::new

One another reference is for arrays. You can form contructor reference with array type. For example: int[]::new is a contructor reference with one parameter: the length of the array. It’s equivalent to the lambda expression x -> new int[x].
.

Lambda expression is a block of code with parameters, you can use it whenever you want, a block of code is executed at later point of time.

Up to now, giving someone a block of code hasn’t been easy in Java. Java is an object-oriented language, so you had to construct an object belonging to a class that has a method with the desied code.

The syntax of lambda expression

(String first, String second) -> {Integer.compare(first.length(), second.length()); }

What is that? The code above is build from three parts:
– parameters,
– an arrow sign,
– the expression

If a lambda expression has no parameters, you still supply empty parentheses:

() -> { for( int i = 0; i < 1000; i++) 
     doSomething();
 }

You can skip parameter types of a lambda expression if it can be inferred

Comparator<String> computation = (first, second) -> Integer.compare(first.length(), second.length());

As you see above you can also skip curly braces if you use single expression for computation only. In example above compiler can deduce that first and second must be strings because the lambda expression is assigned to a string comparator.

If a method has a single parameter with inferred type, you can even omit the parentheses:

EventHandler<ActionEvent> listener = event -> Logger.debug("Button clicked!");
 //Instead of (event) -> or (ActionEvent event)

Parameters can be declared as final or with annotations:

(final String name, @NotNull String email) -> ...

Result type is never defined. It is always inferred from context.

Functional Interfaces

There are many existing interfaces in Java that encapsulate blocks of code. Good examples are: Comparator, Callable, Runnable or EventHandler.
Lambdas are backward compatible with these interfaces.

Functional Interfaces are interfaces with single abstract method. You can supply a lambda expression whenever an object of such interface is expected.

To demonstrate the conversion to functional interface look at Array.sort method. Its second parameter requires an instance of Comparator. Comparator is single method interface as I told above. Example how it works:

Arrays.sort( words, (first, second) -> Integer.compare(first.length(), second.length()));

What was made behind the scenes? The Arrays.sort receives an object of some class that implements Comparator<String>. Invoking the compare method on that object executes the body of the lambda expression. The management of these objects and classes is completely implementation dependent, and it can be much more efficient than using traditional expression as a function, not an object, and to accept that it can be passed to a functional interface.

In fact, conversion to a functional interface is the only thing you can do with a lambda expression in Java. In other programming languages that support function literals, you can declare function types such as (String, String) -> int, declare variables of those types, and use the variables to save function expressions.

The java.util.function package

The Java API defines a number of very generic functional interfaces in the java.util.function package. Take a look on few of them:

public interface Predicate<T>{
    boolean test(T t);
}

public interface Function<T, R>{
    R apply(T t);
}

public interface binaryOperator<T>{
    T apply(T left, T right);
}

public interface Consumer<T>{
    void accept(T t);
}

public interface Supplier<T>{
    T get();
}

You can use it with your own code when work with lambdas

Example:

Supposing we had a functional interface named Predicate declared as follows:

public inteface Predicate<T>{
    boolean test(T t);
}

And we have Person entity:

public class Person {
    public enum Gender {
       MALE,
       FEMALE
    }

    private String name;
    private Gender gender;
    private int age;


    //getters and setters
}

We can write utility method that filter an array of Person entities as we want. We use as first parametes list of entities, and as second Predicate interface to check filtering conditions as follows:

public static filter(Collection<Person> community, Predicate<Person> predicate) {
    Collection<Person> result = new ArrayList<Person>();
    for(Person p : community){
        if(predicate.text(p)){
            result.add(p);
        }
    }
    return result;
}

Now we can filter our collection as we want, for example:

Collection<Person> males = Person.filter(getPersonCollection(), person -> Person.Gender.MALE == person.getGender());//filtering only Males.
Collection<Person> young = Person.filter(getPersonCollection(), person -> person.getAge() < 35);//filter by age lower than 35

In examples above getPersonCollection() is method that return Collection<Person> object.
.

Preparation

As example I’ll use Kotlin Language repository from github.com (I like Kotlin and I’m proud of it :))

First we clone repository:

git clone git@github.com:marioosh/kotlin.git
cd kotlin

marioosh is my github’s username use your own in this place. Don’t forget to fork the repository you are interested in.

Upstream tracking

Now it’s time to set up upstream branch. This branch point to original repository you’ve forked from.

git remote add upstream git@github.com:JetBrains/kotlin.git

In the repository should be now 2 branches:

> git remote -v
origin  git@github.com:marioosh/kotlin.git (fetch)
origin  git@github.com:marioosh/kotlin.git (push)
upstream    git@github.com:JetBrains/kotlin.git (fetch)
upstream    git@github.com:JetBrains/kotlin.git (push)

Fetching

Sync process needs two steps – fetching and merging. Fetch from remote repository will bring in commits, that are stored in your local repository.

git fetch upstream

To finish syncing process we have to merge upstream into our master branch.

git checkout master
git merge upstream/master

.

Then, what is Tuple?

Tuple in Scala is part of the Collections API.
Tuple combines a fixed number of items together and all can be used as one object. Tuples can hold objects with different types (unlike an array or list) and are immutable.

What means Tuple is collection with fixed size?

Every Tuple you define is one of the class :Tuple2, Tuple3, …,Tuple22 .The number in name of class is an amount of items this object can hold. Then if you use Tuple3 class, you can hold only 3 items in it. And yes, upper limit is 22 because there is no Tuple23 class in API.

How to use it:

The standard way is new object invocation from class:

val t = new Tuple3(1, false, "hello")

Example above show us tuple that holds Integer, Boolean and String.
But there are the simplest way. In fact, you no need to invoke a class. You just put all items inside rounded braces:

val t = (1, false, "hello")

The actual type of a tuple depends upon the number and of elements it contains and the types of those elements. Thus, the type of (99, „none”) is Tuple2[Int, String].

Tuples are collections and you can access any element in it. Scala provides elements-access methods for every tuple class. To access elements of a tuple t, you can use method t._1 to access the first element, t._2 to access the second, and so on.

val sumOfFirstThreeElements = t._1 + t._2 + t._3

There is an iterator for iterate over collection. You get it by use Tuple.productIterator() method.

val t = (1,2,3,4,5)
t.productIterator.foreach{ println _ }
//or
val ti = t.productIterator
while(ti.hasNext) println(xi.next)

Convert to String

Tuples override toString() method to pretty print what it contains:

val t = ( 4,3,1,2)
t.toString()

Tuple2

Class Tuple2 has few differences between other tuples. Two are worth few words.
First, most important, is another type of declaration. We can use -> as separator both elements.

scala> 1 -> 2
res0: (Int, Int) = (1,2)

this method you see new Map is invoked.

Map(1 -> 2)

Another addition is swap method.
Tuple2 has a method Tuple2.swap that swaps elements, for example:

val s = ("world", "hello")
s.swap.toString()
scala> (hello,world)

Remember the swap method is only in the Tuple2 class.

Where can I use Tuples?

Anywhere! In fact you use tuples when you use Maps. All elements in maps are stored as Tuple2, (example from REPL):

scala> val m = Map(1 -> "first element", 2 -> "second element")
m: scala.collection.immutable.Map[Int,String] = Map(1 -> first element, 2 -> second element)
scala> m.foreach(kv =>  println(kv.swap))
(first element,1)
(second element,2)

You can use tuples to assign multiple variables at once:

scala> val (x, y z) = ( 1, false, "none")
scala> val (x , y, z) = ( 1, false, "none")
x: Int = 1
y: Boolean = false
z: String = none

.