((LinearLayout.LayoutParams) view.getLayoutParams()).setMargins(0,0,0,0);

               {or}

((LinearLayout.LayoutParams) view.getLayoutParams()).topMargin = 5;

OR

You can create a LayoutParams variable and set margins to it. And set LayoutParams back to the view. as below

LinearLayout.LayoutParams parmas = (LinearLayout.LayoutParams) holder.imageView.getLayoutParams();
            parmas.setMargins(0,5,0,0);
            holder.imageView.setLayoutParams(parmas);

OR

You can use it in more generic way without specifying the particular Layout.

If the view is inside RelativeLayout.

RelativeLayout.LayoutParmas

Or you can use generic ViewGroup.MarginLayoutParams without specifying parent

if (view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
        ViewGroup.MarginLayoutParams mp = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
        mp.setMargins(0,5,0,0);
        view.requestLayout();
    }

The post Change margin of a view programmatically? appeared first on MaXEster Technologies | Technical Blog.

Method references in java are a special type of lambda expressions. because they’re often used to create simple lambda expressions by referencing existing methods.

It is compact and easy form of lambda expression. Each time when you are using lambda expression to just referring a method, you can replace your lambda expression with method reference.

So in this , we are explaining method reference in java concept in detail.

Types of method reference in java.

1. Method Reference to a static method.
2. Reference to a instance method.
3. Reference to a constructor.

1. Method Reference to a static method.

syntax :-

ContainingClass::staticMethodName

Example:-

In the below example, we have defined a functional interface and referring a static method to it’s functional method max().

interface Maxester{  
    void max();  
}  
public class MethodReference {  
    public static void welcome(){  
        System.out.println("Welcome, this is static method.");  
    }  
    public static void main(String[] args) {  
        // Referring static method  
        Maxester maxester = MethodReference::welcome;  
        // Calling interface method  
        maxester.max();  
    }  
}  

Output:-

Welcome, this is static method.

2. Reference to a instance method.

syntax:-

 containingObject::instanceMethodName 

Example:-

In the below example, we are referring non-static methods. we can refer methods by class object and also an anonymous object.

interface Maxester{  
    void max();  
}  
public class InstanceMethodReference {  
    public void welcome(){  
        System.out.println("Welcome, this is instance method.");  
    }  
    public static void main(String[] args) {  
        InstanceMethodReference methodReference = new InstanceMethodReference(); // Creating object  
        // Referring non-static method using reference  
            Maxester maxester = methodReference::welcome;  
        // Calling interface method  
            Maxester.max();  
            // Referring non-static method using anonymous object  
            Maxester maxester_first = new InstanceMethodReference()::welcome; // You can use anonymous object also  
            // Calling interface method  
            maxester_first.max();  
    }  
}  

Output:-

Welcome, this is instance method.

Welcome, this is instance method.

3. Reference to a constructor.

syntax:-

 ClassName::new

Example:-

Interface Maxester{
      NewMaxester max(String value);
}
class NewMaxester{
      NewMaxester(String value){
         System.out.prinln(value);
     }
}
public class ConstrutorRefrenceMethod{
      public static void main(String[] args){
             Maxester maxester = NewMaxester::new;
             maxester.max("Welcome to maxester constructor");
        }
}

output:-

Welcome to maxester constructor.

External Link:-

You can also read much more about Method Reference from below link.

https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

So i hope, This will be helpful for you.

ThankYou.

The post Method Reference In Java 8. appeared first on MaXEster Technologies | Technical Blog.

And, Lambda expression in java also provides a clear and concise way to represent one method interface using an expression.

It is also very useful in the collection library. It helps to iterate, filter and extract data from the collection.

Functional Interface

An interface that has only one abstract method is called a functional interface.

But,

Lambda Expressions in Java also provides an annotation @FunctionalInterface, which is used to declare an interface as a functional interface.

Important Characteristics of a lambda expression.

1.Optional type declaration:

No need to declare the type of a parameter.

Also, The compiler can inference the same from the value of the parameter.

2. The optional parenthesis around parameter :

No need to declare a single parameter in parenthesis.

But, For multiple parameters, parentheses are required.

3. Optional curly braces

No need to use curly braces in the expression body if the body contains a single statement. Then, it is optional to return keyword

4. Optional return keyword

The compiler automatically returns the value if the body has a single expression to return the value.

Also, Curly braces are required to indicate that expression returns a value.

Why We Use Lambda Expression?

1. To provide the implementation of a Functional interface.
2. Less coding.

Syntax Of Lambda Expression

• no parameter syntax

() -> {  
//Body of no parameter lambda  
}
//Lambda Expressions in Java.

• one parameter syntax

(s1) -> {  
//Body of one parameter lambda  
}

//Lambda Expressions in Java.

• two-parameter syntax

(s1,s2) -> {  
//Body of two parameter lambda  
}

//Lambda Expressions in Java.

Example:-

Without using Lambda Expression:

//Lambda Expressions in Java.

interface MyLambda{  
    public void lambda();  
}  
public class LambdaExample {  
    public static void main(String[] args) {  
        String name = "XYZ";  
  
        //without lambda, MyLambdaimplementation using anonymous class  
        MyLambda ml=new MyLambda(){  
            public void lambda(){System.out.println("Hello,  "+name);}  
        };  
        ml.lambda();  
    }  
}  

//Lambda Expressions in Java.

Output:  

Hello, XYZ

Using Lambda Expression:

//Lambda Expressions in Java.

@FunctionalInterface  //It is optional 
interface MyLambda{  
    public String lambda(String name);  
}  
  
public class LambdaExample{  
    public static void main(String[] args) {  
      
        // Lambda expression with single parameter.  
        MyLambda my1=(name)->{  
            return "Hello, "+name;  
        };  
        System.out.println(my1.lambda("XYZ"));  
          
        // You can omit function parentheses    
        MyLambda my2= name ->{  
            return "Hello, "+name;  
        };  
        System.out.println(my2.lambda("ABC"));  
    }  
}

//Lambda Expressions in Java. 

Output: 

Hello, XYZ
Hello, ABC

You can also use no parameter and multiple parameters lambda expression as in the above example.

Then, you can see How Lambda Expression is very useful.

Also, I hope, this will be helpful for you.

You can also visit on below link for a brief Introduction about Lambda Expressions in Java.

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

ThankYou.

The post Lambda Expressions in Java. appeared first on MaXEster Technologies | Technical Blog.