protected final AgentContext getAgentContext() {

        AgentContext context = m_contextRef.get();

        if (context == null) {

            throw new IllegalStateException("Handler is not started: " + m_identifier);

        }

        return context;

    }

public void updateBidForKeyword(Long adGroupId, Long keywordId, Long bidAmount) {

      

               AdWordsSession adwordSession = null;

   

               // initialize AdWords session



                try {

            // Generate a refreshable OAuth2 credential

            Credential oAuth2Credential = new OfflineCredentials.Builder().forApi(Api.ADWORDS)

                  .fromFile().build()

                  .generateCredential();



            // Construct an AdWordsSession.

            adwordSession = new AdWordsSession.Builder().fromFile().withOAuth2Credential(oAuth2Credential).build();



         } catch (Exception ex) {

                               

         }

              

                // Get CampaignCriterionService using AdWordsSession



                AdWordsServices adWordsServices = new AdWordsServices();



      CampaignCriterionServiceInterface campaignCriterionService = adWordsServices.get(adwordSession, CampaignCriterionServiceInterface.class);

               

      AdGroupCriterionServiceInterface adGroupCriterionService = GoogleAuthenticationService

            .getAdGroupCriterionService();



      Keyword keyword = new Keyword();

      keyword.setId(keywordId);



      BiddableAdGroupCriterion keywordBiddableAdGroupCriterion = new BiddableAdGroupCriterion();

      keywordBiddableAdGroupCriterion.setAdGroupId(adGroupId);

      keywordBiddableAdGroupCriterion.setCriterion(keyword);



      BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration();

      CpcBid bid = new CpcBid();

      bid.setBid(new Money(null, bidAmount));

      biddingStrategyConfiguration.setBids(new Bids[] { bid });

      keywordBiddableAdGroupCriterion.setBiddingStrategyConfiguration(biddingStrategyConfiguration);



      AdGroupCriterionOperation keywordAdGroupCriterionOperation = new AdGroupCriterionOperation();

      keywordAdGroupCriterionOperation.setOperand(keywordBiddableAdGroupCriterion);

      keywordAdGroupCriterionOperation.setOperator(Operator.SET);



      AdGroupCriterionOperation[] operations = new AdGroupCriterionOperation[] { keywordAdGroupCriterionOperation };



      AdGroupCriterionReturnValue result = null;



      try {

         result = adGroupCriterionService.mutate(operations);

      } catch (Exception e) {

         e.printStackTrace();

      }

      

      // Display campaigns.

      for (AdGroupCriterion campaignCriterion : result.getValue()) {

         System.out.printf("Campaign criterion with criterion ID %d, " + "and type '%s' was added.%n",

               campaignCriterion.getCriterion().getId(), campaignCriterion.getCriterion().getCriterionType());

      }



   }

// Create selector

Selector selector = new Selector();

selector.getFields().addAll(Arrays.asList("Id","Criteria","Conversions"));

      

Predicate predicate = new Predicate();

predicate.setField("CampaignId");

PredicateOperator predicateOperator = PredicateOperator.EQUALS;

predicate.setOperator(predicateOperator);

predicate.getValues().add(campaignId);

      

selector.getPredicates().add(predicate);

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use Stream, Predicate and Filter to get the count of elements more than 1



System.out.println(intSet.stream().filter(moreThan2Pred).count()); // Prints 3

class BuggyBread { 

   public static void main(String[] args)

   {

      String s2 = "I am unique!"; 

      String s5 = "I am unique!";

        

      System.out.println(s2 == s5); // prints true

   } 

}

class BuggyBread1 {

     public String method() {

          return "Base Class - BuggyBread1";

     }

}



class BuggyBread2 extends BuggyBread1{ 

  

     private static int counter = 0;

 

     public String method(int x) {

         return "Derived Class - BuggyBread2";

     }

      

     public static void main(String[] args) {

          BuggyBread1 bg = new BuggyBread2();  

          System.out.println(bg.method()); // prints Base Class - BuggyBread1

     } 

}

    public RelNode convert(RelNode rel) {

      final LogicalProject project = (LogicalProject) rel;

      final RelTraitSet traitSet = project.getTraitSet().replace(out);

      return new MongoProject(project.getCluster(), traitSet,

          convert(project.getInput(), out), project.getProjects(),

          project.getRowType());

    }

public final class EmployeeFactory {



   private Employee svEmp;

   

   public EmployeeFactory(String type){

      if( type.equals("Manager")){

         svEmp = new Manager();

      } else if(type.equals("Developer")){

         svEmp = new Developer();

      } else if(type.equals("QA")){

         svEmp = new QA();

      }

   }

   

   public Employee getFactoryProduct() {

      return svEmp;

   }

   

}

Using String method -



new StringBuffer(str).reverse().toString();



Iterative -



Strategy - Loop through each character of a String from last to first and append the character to StringBuilder / StringBuffer



public static String getReverseString(String str){

   StringBuffer strBuffer = new StringBuffer(str.length);

   for(int counter=str.length -1 ; counter>=0;counter--){

      strBuffer.append(str.charAt(counter));

   } 

   return strBuffer;

}



Recursive -



Strategy - Call the method with substring starting from 2nd character recursively till we have just 1 character. 



public static String getReverseString(String str){

   if(str.length <= 1){

      return str;

   }

   return (getReverseString(str.subString(1)) +      str.charAt(0);

} 

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Set the predicate or the condition for filtering the elements.



Predicate<Integer> moreThan2Pred = (p) -> (p > 1); 



// Use Filter to refine the element set, sort to Sort and Collectors.toSet to get a set out of Stream.



intSet =  intSet.stream().filter(moreThan2Pred).sorted().collect(Collectors.toSet());

    

System.out.println(intSet); // Prints [2, 3, 4]

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Specify the Predicate or the Condition using Lambda expressions



Predicate<Integer> moreThan2Pred = (p) -> (p > 2); 



// Use the stream method allMatch to see if all elements fulfils the Predicate.

// Populate a List using Set elements.



// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();

Set<Integer> intSet2 = new HashSet<Integer>(); 



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);

intSet2.add(1);

intSet2.add(2);

intSet2.add(3);

intSet2.add(4); 



// Use the stream and collectors to Summarize all Integer elements 



IntSummaryStatistics summary = intSet.stream().collect(Collectors.summarizingInt(p->((Integer)p)));

 

summary.combine(intSet2.stream().collect(Collectors.summarizingInt(p->((Integer)p))));

 

System.out.println(summary); // Prints IntSummaryStatistics{count=8, sum=20, min=1, average=2.500000, max=4}

Random rand = new Random();

int randomNumber = rand.nextInt(100);

Map<String,List<String>> capitals = new HashMap();

capitals.put("United States", Arrays.asList("Washington DC"));

capitals.put("Canada", Arrays.asList("Ottawa"));

capitals.put("South Africa", Arrays.asList("Pretoria", "Cape Down", "Bloemfontein"));

      

for(Map.Entry<String,List<String>> entry: capitals.entrySet()){

   if(entry.getValue().size() > 1){

      System.out.println(entry.getKey());

   }

}

private static final Logger LOGGER = Logger.getLogger(BuggyBread.class);



public static void main(String[] args) {

   try {

      // Do Something   

   } catch (Throwable t) {

      LOGGER.error("Shit Happens");

   } finally {

      // release the connections

   }

}

double randomNo = Math.random();

System.out.println((int)(randomNo*100));

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream and Collector to find the average of all elements.



System.out.println(intSet.stream().collect(Collectors.averagingInt(p->((Integer)p))));  Prints 2.5

public void calculateSum() {

   Scanner scanner=new Scanner(System.in); 

   int sum=0;

   for(int counter=1;counter<=10;counter++) 

      sum=sum+(scanner.nextInt());



   System.out.println("The sum is: "+sum);

}

public enum State {

   NEVADA, CALIFORNIA, WASHINGTON;

}



public static void method(States stateName) {

 switch (stateName) {

   case NEVADA:

   System.out.println("You are in Nevada");

   break;



   case CALIFORNIA:

   System.out.println("You are in California");

   break;



   case WASHINGTON:

   System.out.println("You are in Washington");

   break;     

 }

}

List<File> fileList = new ArrayList();



List<File> read(String dir) throws IOException{   

   File directory = new File(dir);

   File[] fList = directory.listFiles();

   for(File file:fList){

      if(file.isDirectory()){

         read(file.getPath());

      } else {

         fileList.add(file);

      }

   }

   return fileList;

}

class Singleton {

   private static volatile Singleton instance = null;

   private Singleton(){}

   public static Singleton getInstance() {

      if (instance == null) {            

         synchronized(Singleton.class) {

            if (instance== null)

               instance = new Singleton(); 

            }

         }

      return instance;

   }

}

String str = "";

if(StringUtils.isEmpty(str)){

    System.out.println("Yes, string is empty");

}

ListValuedMap<String,String> listValuedMap = new ArrayListValuedHashMap();

listValuedMap.put("United States", "Washington");

listValuedMap.put("Canada", "Ottawa");

listValuedMap.put("Canada", "Ottawa");

listValuedMap.put("South Africa", "Pretoria");

listValuedMap.put("South Africa", "Cape Town");

listValuedMap.put("South Africa", "Bloemfontein");



System.out.println(listValuedMap); // Values being added to the List and allow even duplicates

    public X509Certificate createCertificate(X500Principal issuerDN, PrivateKey issuerKey, String name, Date notBefore, Date notAfter, PublicKey key) throws IllegalArgumentException {

        try {

            X500Name issuer = new X500Name(issuerDN.getName());

            X500Name commonName = new X500Name(name);

            BigInteger serial = BigInteger.valueOf(++m_serial);



            SubjectPublicKeyInfo pubKeyInfo = convertToSubjectPublicKeyInfo(key);



            X509v3CertificateBuilder builder = new X509v3CertificateBuilder(issuer, serial, notBefore, notAfter, commonName, pubKeyInfo);



            X509CertificateHolder certHolder = builder.build(new JcaContentSignerBuilder(SIGNATURE_ALGORITHM).build(issuerKey));

            return new JcaX509CertificateConverter().getCertificate(certHolder);

        }

        catch (IllegalArgumentException e) {

            throw e;

        }

        catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

public class Stack{

   static int top = 0;

   static Element[] stack = new Element[10];

   

   static class Element {

      int body;

      

      Element(int value){

         body = value;

      }

   }

   

   public static void main(String[] args){

      push(5);

      System.out.println(top);

      push(7);

      System.out.println(top);

      poll();

      System.out.println(top);

      poll();

      System.out.println(top);   

   }

   

   private static void push(int value){

      Element newElement = new Element(value);

      top++;

   }

   

   private static Element poll(){

      Element topElement = stack[top];

      top--;

      return topElement;

   }

}

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream method count to see if all elements fulfils the Predicate.



System.out.println(intSet.stream().count); // Prints 4.

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream and Collector to Group by Even and Odd



System.out.println(intSet.stream().collect(Collectors.groupingBy(p->((Integer)p)%2)));  Prints {0=[2, 4], 1=[1, 3]}

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream and collectors to sum all elements.



System.out.println(intSet.stream().collect(Collectors.summingInt(p->(Integer)p)));

double randomNo = Math.random();

System.out.println(randomNo);

List<String> list = new ArrayList();

list.add("Washington");

list.add("Nevada");

list.add("California");



PermutationIterator permIterator = new PermutationIterator((Collection) list);

        

permIterator.forEachRemaining(System.out::print); // prints [Washington, Nevada, California][Washington, California, Nevada][California, Washington, Nevada][California, Nevada, Washington][Nevada, California, Washington][Nevada, Washington, California]

@Entity

@Table(name = "EMPLOYEE")

public class Employee {

   @ManyToOne(fetch = FetchType.LAZY)

   private Set<Department> dept = new Department();

}

import org.pojomatic.Pojomatic;

import org.pojomatic.annotations.AutoProperty;



@AutoProperty

public class Employee {

   public String name;

   public int age;

   public int salary;



   public String getName() {

      return name;

   }



   public void setName(String name) {

      this.name = name;

   }



   public int getAge() {

      return age;

   }



   public void setAge(int age) {

      this.age = age;

   }



   public int getSalary() {

      return salary;

   }



   public void setSalary(int salary) {

      this.salary = salary;

   }



   @Override

   public int hashCode() {

      return Pojomatic.hashCode(this);

   }



   @Override

   public boolean equals(Object other) {

      return Pojomatic.equals(this, other);

   }



   @Override

   public String toString() {

      return Pojomatic.toString(this);

   }

}

public interface SampleInterface {

   public int sampleMethod(List sampleList);



   static class Impl implements SampleInterface {



      @Override

      public int sampleMethod(List sampleList) {

         return 0;

      }

   }

}

    public static String encode(String source) {

        if (source == null) {

            return "$e";

        }

        StringBuffer result = new StringBuffer();

        StringCharacterIterator sci = new StringCharacterIterator(source);

        for (char c = sci.current(); c != CharacterIterator.DONE; c = sci.next()) {

            if (c == '$') {

                result.append("$$");

            }

            else if (c == ',') {

                result.append("$k");

            }

            else if (c == '
') {

                result.append("$n");

            }

            else if (c == '
') {

                result.append("$r");

            }

            else {

                result.append(c);

            }

        }

        return result.toString();

    }

// Populate a List using Set elements.



// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream and collectors to Summarize all Integer elements 



System.out.println(intSet.stream().collect(Collectors.summarizingInt(p->((Integer)p)))); // Prints IntSummaryStatistics{count=4, sum=10, min=1, average=2.500000, max=4}

package Reader;



import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;



import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.NameValuePair;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.client.methods.HttpRequestBase;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.util.EntityUtils;



import com.squareup.okhttp.MediaType;

import com.squareup.okhttp.OkHttpClient;



public class BlogPostCreater {

      

   public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");



   OkHttpClient client = new OkHttpClient();

    

   String post(String title, String content,String label,String authorization_key) throws IOException {

      

      content = content.replace(""",""");

      

      

      String url = "https://www.googleapis.com/blogger/v3/blogs/xxxxxxxxxx/posts?clientId=xxxxxxxx&clientSecret=xxxxxxxx";



      HttpClient client = new DefaultHttpClient();

      HttpPost post = new HttpPost(url);



      // add header

      post.setHeader("Authorization", authorization_key);

      post.setHeader("Content-type","application/json");

      

      post.setEntity(new StringEntity(buildJson(title,content,label)));

       

      HttpResponse response = client.execute(post);

            

      System.out.println(response);

      

      return "true";

    }

   

      



     String buildJson(String title, String content,String label) {

       

        System.out.println(label);

        return "{"status": "LIVE", "content": ""+content+"", "kind": "blogger#post"" +

             ", "title": ""+title+"", "url": "xxxxxx", " +

             ""readerComments": "DONT_ALLOW_HIDE_EXISTING", "author": {" +

             ""url": "https://www.blogger.com/profile/04326686331881561093", " +

             ""image": {" +

             ""url": "//lh4.googleusercontent.com/-64Ucx9lX9Q4/AAAAAAAAAAI/AAAAAAAAAx0/-rUjBgS3djE/s35-c/photo.jpg"" +

             "}, " +

             ""displayName": "Vivek Vermani", " +

             ""id": "g108356395081185480077"" +

             "}, "updated": "2015-09-28T09:46:12+05:30", "replies": {"totalItems": "0", " +

             ""selfLink": "https://www.googleapis.com/blogger/v3/blogs/xxxxxxxxxx/posts/2495464003469367152/comments"" +

             "}, "blog": {"id": "4275342475651800664"}, " +

             ""etag": "'GtyIIQmNmmUjEA0nwhSqMElCJ1g/dGltZXN0YW1wOiAxNDQzNDEzNzcyMDc1Cm9mZnNldDogMTk4MDAwMDAK'", " +

             ""published": "2015-09-28T09:46:00+05:30", " +

             ""id": "2495464003469367152", " +

             ""selfLink": "https://www.googleapis.com/blogger/v3/blogs/xxxxxx/posts/2495464003469367152"}";

     }

     

     public String post(String url, Map<String,String> formParameters) throws ClientProtocolException, IOException { 

        HttpPost request = new HttpPost(url);

          

        List <NameValuePair> nvps = new ArrayList <NameValuePair>();

         

        for (String key : formParameters.keySet()) {

         nvps.add(new BasicNameValuePair(key, formParameters.get(key))); 

        }

       

        request.setEntity(new UrlEncodedFormEntity(nvps));

         

        return execute(request);

       }



   // makes request and checks response code for 200

     private String execute(HttpRequestBase request) throws ClientProtocolException, IOException {

      HttpClient httpClient = new DefaultHttpClient();

      HttpResponse response = httpClient.execute(request);

          

      HttpEntity entity = response.getEntity();

         String body = EntityUtils.toString(entity);

     

      if (response.getStatusLine().getStatusCode() != 200) {

       throw new RuntimeException("Expected 200 but got " + response.getStatusLine().getStatusCode() + ", with body " + body);

      }

     

         return body;

     }

     

     

}

Map<String,List<ClassInfoBean>> removeDuplicates(Map<String, List<ClassInfoBean>> interfaceMap){

   Map<String, List<ClassInfoBean>> interfaceMapWithoutDuplicate = new HashMap();

      

   for(Map.Entry<String, List<ClassInfoBean>> entry: interfaceMap.entrySet()){

      List<ClassInfoBean> classListWithoutDuplicate = new ArrayList();

      boolean alreadyContain = false;

      for(ClassInfoBean classes: entry.getValue()){

         for(ClassInfoBean classes1: classListWithoutDuplicate){

            if(classes1.name.equalsIgnoreCase(classes.name)){

               alreadyContain = true;

               break;

            }

         }

         if(alreadyContain == false){

            classListWithoutDuplicate.add(classes);

         }

      }

      interfaceMapWithoutDuplicate.put(entry.getKey(), classListWithoutDuplicate);

   }

      

   return interfaceMapWithoutDuplicate;

}

String str = new String("1H4ello1 World2"); 



String newStr = CharSetUtils.delete(str, "1234567890");



System.out.println(newStr); // prints Hello World

  public static void main(String[] args) {

    SparkConf conf = new SparkConf().setAppName("JavaLogisticRegressionWithElasticNetExample");

    JavaSparkContext jsc = new JavaSparkContext(conf);

    SQLContext sqlContext = new SQLContext(jsc);



    DataFrame training = sqlContext.read().format("libsvm")

      .load("data/mllib/sample_libsvm_data.txt");



    LogisticRegression lr = new LogisticRegression()

      .setMaxIter(10)

      .setRegParam(0.3)

      .setElasticNetParam(0.8);



    LogisticRegressionModel lrModel = lr.fit(training);



    System.out.println("Coefficients: "

      + lrModel.coefficients() + " Intercept: " + lrModel.intercept());



    jsc.stop();

  }

int count = 0; // int is a keyword, count is an identifier and 0 is a literal

public interface Calc {

    int square(int value);

}



public static void main(String[] args){

    Calc calc = (int val) -> val * val;

    System.out.println(calc.square(5));

}

public class BuggyBread1 {

   

   public static void main(String args[]) {

      

      // Declare and Initialize the Collection

      Set<Integer> intSet = new HashSet<Integer>();



      // Add Elements

      intSet.add(1);

      intSet.add(2);

      intSet.add(3);

      intSet.add(4);

      intSet.add(5);



      double averageOfNonPrimeFactorials = intSet.stream().filter(p->checkIfPrime(p)).collect(Collectors.averagingInt(p->calculateFactorial(p)));

      

      System.out.println(averageOfNonPrimeFactorials );

   }

   

   static private boolean checkIfPrime(int num){

      for(int count=2;count < num;count++){

         if(num % count == 0){

            return false;

         }

      }

      return true;

   }

   

   static private int calculateFactorial(int num){

      int factorial = 1;

      for(int count=num;count > 0;count--){

         factorial = factorial * count;

      }

      return factorial;

   }

}

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;



import com.google.common.collect.ArrayListMultimap;

import com.google.common.collect.Multimap;



public class Graph {

   private static Multimap<Integer,Integer> adjacentDirectedNodesMap = ArrayListMultimap.create();

   private static Set<Integer> alreadyVisited = new HashSet();

   

   static{

      adjacentDirectedNodesMap.put(1, 2);

      adjacentDirectedNodesMap.put(1, 3);

      adjacentDirectedNodesMap.put(1, 5);

      adjacentDirectedNodesMap.put(2, 4);

      adjacentDirectedNodesMap.put(4, 5);

   }

   

   public static void main(String[] args){

      ArrayList visited = new ArrayList();

      

      Integer startNode = 1;

      

      displayAdjacentNodes(startNode);

      

   }

   

   private static void displayAdjacentNodes(Integer integer){

      System.out.println(integer);

      for(Map.Entry<Integer, Collection<Integer>> adjacentNodes: adjacentDirectedNodesMap.asMap().entrySet()){

         for(Integer integer1:adjacentNodes.getValue()){

            if(alreadyVisited.contains(integer1)){

               continue;

            }

            alreadyVisited.add(integer1);

            System.out.println(integer1);

         }

      }

   }

   

}

public abstract class TestClass {

   public static void main(String[] args){

      }

}

public abstract class TestClass {



      protected static final String TEST_STRING = "test";



      public static void main(String[] args){

      }

}

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Specify the Predicate or the Condition using Lambda expressions



Predicate<Integer> moreThan2Pred = (p) -> (p > 2); 



// Use the stream method anyMatch to see if all elements fulfils the Predicate.



System.out.println(intSet.stream().anyMatch(moreThan2Pred)); // Prints True.

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Specify the Predicate or the Condition using Lambda expressions



Predicate<Integer> moreThan2Pred = (p) -> (p > 2); 



// Use the stream method noneMatch to see if all elements fulfils the Predicate.



System.out.println(intSet.stream().noneMatch(moreThan2Pred)); // Prints False.

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream and collectors to get List out of Set



List li = intSet.stream().collect(Collectors.toList());

System.out.println(li); // Prints [1, 2, 3, 4]

// Declare and Initialize the Collection



Set<Integer> intSet = new HashSet<Integer>();



// Add Elements



intSet.add(1);

intSet.add(2);

intSet.add(3);

intSet.add(4);



// Use the stream and collectors to get a Map out of Set 



System.out.println(intSet.stream().collect((Collectors.toMap(p->(Integer)p,q->((Integer)q)*500)))); // Prints {1=500, 2=1000, 3=1500, 4=2000} 

String str = new String().concat("Explain").concat("This").concat("Code");

String text="vivek boy goy vivek@tech.com viv@ek.com sdjs@adjk";

Pattern regex = Pattern.compile("[@]");

Matcher regexMatcher = regex.matcher(text);

int i =0;

int width = 0;

while (regexMatcher.find()) {

     if((regexMatcher.start()-10 > 0) && (regexMatcher.end()+10 < text.length())){

          width=10;

       String[]    substr=text.substring(regexMatcher.start()-width,regexMatcher.end()+width).split(" ");

           for(int j=0;j<substr.length;j++){

                   if(substr[j].contains("@") && (substr[j].contains(".com") ||    substr[j].contains(".net"))){

                                System.out.println(substr[j]);

                           }                

                     }

               } else {

               width=0;

        }

 }

String text = "I don't think we're in Kansas anymore";



// Usage string.substring(startIndex,endIndex)



String subStringText = text.substring(0,2);



System.out.println(subStringText); // prints I d

public enum JavaFramework {

   SPRING("Spring","Web"),

   STRUTS("Struts","Web"),

   JSF("JSF","View"),

   CRUNCH("Apache Crunch","BigData");

   

        

   public String name;

   public String type;



   JavaFramework(String name, String type){

      this.name = name;

      this.type = type;

   }

   

   static public List<JavaFramework> getByType(String type)  {

      List<JavaFramework> frameworks = new ArrayList();

      for(JavaFramework framework: JavaFramework.values()){

         if(framework.type.equalsIgnoreCase(type)){

            frameworks.add(framework);

         }

      }

      

      return frameworks;

   }

}

@Path("/employeeInfo")

public class RestWebServiceJersey {

   @GET

   @Path("/detail/{employeeId}")

   @Produces(MediaType.APPLICATION_JSON)

   public String getEmployeeInfo(@PathParam("employeeId") String employeeId) {

      JSONObject jsonObj = new JSONObject();

      jsonObj.put("EmployeeName", "Sam");

      jsonObj.put("EmployeeDept", "Marketing");

      return jsonObj.toString();

   }

}

List getSpreadSheetData() throws IOException, ServiceException{

   List<SpreadsheetEntry> spreadsheetData = Service.getSpreadSheetData("<Spreadsheet Url>");

            

    SpreadsheetService service = new SpreadsheetService("MySpreadsheetIntegration-v1");

   URL SPREADSHEET_FEED_URL = new URL(url);



   SpreadsheetFeed feed = service.getFeed(SPREADSHEET_FEED_URL, SpreadsheetFeed.class);

   List<SpreadsheetEntry> spreadsheet = feed.getEntries();

   return spreadsheet;

}

HelloJava8Base 



public class HelloJava8Base {

     public void defaultMethod() {

         System.out.println("Default Method Base Class Implementation");

     }

}



DefaultMethodInterface 



public interface DefaultMethodInterface {

     default public void defaultMethod() {

         System.out.println("Default Method Interface Implementation");

     }

}



HelloJava8



public class HelloJava8 extends HelloJava8Base implements DefaultMethodInterface,DefaultMethodInterface2 {

   public static void main(String[] args){

       DefaultMethodInterface dmi = new HelloJava8();

       dmi.defaultMethod(); // Prints "Default Method Base Class Implementation"

    }

}

String string = "I don't think we are in Kansas anymore";

String splittedString = str1.split(" ");

int count = 1;

for(String str: splittedString){

   System.out.println("Word number:" + count + ":" + str);

   count++;

}

public class Employee {

   public String name;

   public int age;

   public int salary;



   Employee(String name, int age, int salary) {

      this.name = name;

      this.age = age;

      this.salary = salary;

   }



   public String getName() {

      return name;

   }



   public void setName(String name) {

      this.name = name;

   }



   public int getAge() {

      return age;

   }



   public void setAge(int age) {

      this.age = age;

   }



   public int getSalary() {

      return salary;

   }



   public void setSalary(int salary) {

      this.salary = salary;

   }

}

List<String> myList = new ArrayList<String>();

myList.add("D");

myList.add("A");

myList.add("B");

myList.add("C");

myList.add("E");



System.out.println(myList); // Unsorted



Collections.sort(myList);



System.out.println(myList); // Sorted

public class BuggyBreadTest {

     public static void main(String[] args) {

          int x = 5;

          boolean isEven = x%2 == 0 ? true:false;

          if(isEven)

             System.out.println("Even");

          else

             System.out.println("Odd"); // prints Odd

     }

}

public class Employee {

     public String name;

     public int age;

     public int salary;

     

     // No Argument Constructor

     Employee(){

        this.name = "";

        this.age = 0;

        this.salary = 0;

     }

     

     // Single Argument Constructor

     Employee(String name){

        this.name = name;

        this.age = 0;

        this.salary = 0;

     }

     

     // Argument Constructor

     Employee(String name,int age){

        this.name = name;

        this.age = age;

        this.salary = 0;

     }

     

     // Argument Constructor

     Employee(String name,int age,int salary){

        this.name = name;

        this.age = age;

        this.salary = salary;

     }

}

public static void main(String[] args) {

      String str = "We are not in Kansas anymore";

      for(char character: str.toCharArray()){

         System.out.println((int)character);

      }

}

public class CoinChanger {

   private static Map<Currency, Integer> cashBox;

   private static Map<Currency, Integer> change;



        enum Currency {

      DOLLAR,QUARTER,DIME,NICKEL,PENNY;

         }



   static {

      cashBox = new TreeMap<Currency, Integer>();

      change = new TreeMap<Currency, Integer>();

      initializeCashBox();

   }



   private static void initializeCashBox(){

      //set the cash box

      cashBox.put(Currency.DOLLAR, 50);

      cashBox.put(Currency.QUARTER, 0);

      cashBox.put(Currency.DIME, 50);

      cashBox.put(Currency.NICKEL, 50);

      cashBox.put(Currency.PENNY, 50);

   }

   }

}

AbstractChronology abstractChrono = ThaiBuddhistChronology.INSTANCE;

System.out.println(abstractChrono.getCalendarType()); // Will print buddhist

AbstractChronology abstractChrono = HijrahChronology.INSTANCE;

System.out.println(abstractChrono.dateNow().minus(6, ChronoUnit.DAYS));

static {

   timer.schedule(new ScheduledTask(), 60000, 60000);

}



private static class Schedule extends TimerTask {

    @Override public void run() {

      //doSomething();

    }

}

private static Properties props = null;

   

private static void loadProperties(){

   try {

      if(props == null || props1 == null || props2 == null){

         props = new Properties();

         props.load(new FileInputStream(Constants.PROP_BASE_DIR + Constants.EMPLOYEE_REPORTING_PROP));

      } catch (FileNotFoundException e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

      } catch (IOException e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

      } 

       

   }

}

public static boolean isOleFile(File file)

{

   if ((file == null) || (!file.exists()) || (file.isDirectory())) {

      return false;

   }

    

   return true;

}

TimeUnit.DAYS.convert(timeinMs, TimeUnit.MILLISECONDS)

PassiveExpiringMap<String,String> cache = new PassiveExpiringMap<String,String>(1000); // Expiration time of 1 sec

cache.put("Key1", "Value1");

System.out.println(cache.containsKey("Key1"));

Thread.sleep(500);

System.out.println(cache.containsKey("Key1"));

Thread.sleep(500);

System.out.println(cache.containsKey("Key1"));

Map<String,String> linkedhashmap = new LinkedHashMap();

linkedhashmap.put("United States", "Washington");

linkedhashmap.put("Canada", "Ottawa");

linkedhashmap.put("Canada", "Ottawa");

linkedhashmap.put("South Africa", "Pretoria");

linkedhashmap.put("South Africa", "Cape Town");

linkedhashmap.put("South Africa", "Bloemfontein");



System.out.println(linkedhashmap); // Duplicates not allowed as it's a Map, Insertion Order as its linked Map

SetValuedMap<String,String> setValuedMap = new HashSetValuedHashMap();

setValuedMap.put("United States", "Washington");

setValuedMap.put("Canada", "Ottawa");

setValuedMap.put("Canada", "Ottawa");

setValuedMap.put("South Africa", "Pretoria");

setValuedMap.put("South Africa", "Cape Town");

setValuedMap.put("South Africa", "Bloemfontein");

        

System.out.println(setValuedMap); // Values being added to the Set and hence doesn't allow duplicates

String str = new String("Hello World"); 

String newStr = CharSetUtils.delete(str, "abcde");

System.out.println(newStr); // prints Hllo Worl

  public BlockCommand(int action, List<BlockTargetPair> blocktargetlist) {

    super(action);



    blocks = new Block[blocktargetlist.size()]; 

    targets = new DatanodeInfo[blocks.length][];

    for(int i = 0; i < blocks.length; i++) {

      BlockTargetPair p = blocktargetlist.get(i);

      blocks[i] = p.block;

      targets[i] = p.targets;

    }

  }

    public void readFields(DataInput in) throws IOException {

      methodName = UTF8.readString(in);

      parameters = new Object[in.readInt()];

      parameterClasses = new Class[parameters.length];

      ObjectWritable objectWritable = new ObjectWritable();

      for (int i = 0; i < parameters.length; i++) {

        parameters[i] = ObjectWritable.readObject(in, objectWritable, this.conf);

        parameterClasses[i] = objectWritable.getDeclaredClass();

      }

    }

    private byte[] deflate(byte[] b) throws IOException {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        DeflaterOutputStream dos = new DeflaterOutputStream(baos);

        dos.write(b);

        dos.close();

        return baos.toByteArray();

    }

    public static Image createDisabledImage (Image i) {

        GrayFilter filter = new GrayFilter(true, 50);

        ImageProducer prod = new FilteredImageSource(i.getSource(), filter);

        Image grayImage = Toolkit.getDefaultToolkit().createImage(prod);

        return grayImage;

    }

        public Instant instant() {

            if ((tickNanos % 1000_000) == 0) {

                long millis = baseClock.millis();

                return Instant.ofEpochMilli(millis - Math.floorMod(millis, tickNanos / 1000_000L));

            }

            Instant instant = baseClock.instant();

            long nanos = instant.getNano();

            long adjust = Math.floorMod(nanos, tickNanos);

            return instant.minusNanos(adjust);

        }

    public static LocalTime from(TemporalAccessor temporal) {

        Objects.requireNonNull(temporal, "temporal");

        LocalTime time = temporal.query(TemporalQueries.localTime());

        if (time == null) {

            throw new DateTimeException("Unable to obtain LocalTime from TemporalAccessor: " +

                    temporal + " of type " + temporal.getClass().getName());

        }

        return time;

    }

  public UnsafeExternalRowSorter(

      StructType schema,

      Ordering<InternalRow> ordering,

      PrefixComparator prefixComparator,

      PrefixComputer prefixComputer,

      long pageSizeBytes) throws IOException {

    this.schema = schema;

    this.prefixComputer = prefixComputer;

    final SparkEnv sparkEnv = SparkEnv.get();

    final TaskContext taskContext = TaskContext.get();

    sorter = UnsafeExternalSorter.create(

      taskContext.taskMemoryManager(),

      sparkEnv.blockManager(),

      taskContext,

      new RowComparator(ordering, schema.length()),

      prefixComparator,

      pageSizeBytes

    );

  }

  public static void main(String[] args) {

    SparkConf conf = new SparkConf().setAppName("JavaStopWordsRemoverExample");

    JavaSparkContext jsc = new JavaSparkContext(conf);

    SQLContext jsql = new SQLContext(jsc);



    StopWordsRemover remover = new StopWordsRemover()

      .setInputCol("raw")

      .setOutputCol("filtered");



    JavaRDD<Row> rdd = jsc.parallelize(Arrays.asList(

      RowFactory.create(Arrays.asList("I", "saw", "the", "red", "baloon")),

      RowFactory.create(Arrays.asList("Mary", "had", "a", "little", "lamb"))

    ));



    StructType schema = new StructType(new StructField[]{

      new StructField(

        "raw", DataTypes.createArrayType(DataTypes.StringType), false, Metadata.empty())

    });



    DataFrame dataset = jsql.createDataFrame(rdd, schema);

    remover.transform(dataset).show();

    jsc.stop();

  }

  public void shouldEmitNothingIfNoObjectHasBeenCountedYetAndTickTupleIsReceived() {

    Tuple tickTuple = MockTupleHelpers.mockTickTuple();

    RollingCountBolt bolt = new RollingCountBolt();

    Map conf = mock(Map.class);

    TopologyContext context = mock(TopologyContext.class);

    OutputCollector collector = mock(OutputCollector.class);

    bolt.prepare(conf, context, collector);



    bolt.execute(tickTuple);



    verifyZeroInteractions(collector);

  }

DistributedLDAModel ldaModel = (DistributedLDAModel)new LDA().setK(3).run(corpus);    

System.out.println("Learned topics (as distributions over vocab of " + ldaModel.vocabSize()        + " words):");   

Matrix topics = ldaModel.topicsMatrix();    for (int topic = 0; topic < 3; topic++) {

  private void validate(String appId, String secretKey, boolean encrypt) throws IOException {

    ExternalShuffleClient client =

      new ExternalShuffleClient(conf, new TestSecretKeyHolder(appId, secretKey), true, encrypt);

    client.init(appId);

    client.registerWithShuffleServer(TestUtils.getLocalHost(), server.getPort(), "exec0",

      new ExecutorShuffleInfo(new String[0], 0, ""));

    client.close();

  }

  public void handleSuccessfulFetch() throws Exception {

    StreamChunkId streamChunkId = new StreamChunkId(1, 0);



    TransportResponseHandler handler = new TransportResponseHandler(new LocalChannel());

    ChunkReceivedCallback callback = mock(ChunkReceivedCallback.class);

    handler.addFetchRequest(streamChunkId, callback);

    assertEquals(1, handler.numOutstandingRequests());



    handler.handle(new ChunkFetchSuccess(streamChunkId, new TestManagedBuffer(123)));

    verify(callback, times(1)).onSuccess(eq(0), (ManagedBuffer) any());

    assertEquals(0, handler.numOutstandingRequests());

  }

  public void shouldEmitSomethingIfTickTupleIsReceived() {

    Tuple tickTuple = MockTupleHelpers.mockTickTuple();

    BasicOutputCollector collector = mock(BasicOutputCollector.class);

    TotalRankingsBolt bolt = new TotalRankingsBolt();



    bolt.execute(tickTuple, collector);



    verify(collector).emit(any(Values.class));

  }

    public static StormTopology buildDevicesTopology() {

        String deviceID = "device-id";

        String count = "count";

        Fields allFields = new Fields(deviceID, count);



        RandomNumberGeneratorSpout spout = new RandomNumberGeneratorSpout(allFields, 10, 1000);



        TridentTopology topology = new TridentTopology();

        Stream devicesStream = topology.newStream("devicegen-spout", spout).

                each(allFields, new Debug("##### devices"));



        devicesStream.minBy(deviceID).

                each(allFields, new Debug("#### device with min id"));



        devicesStream.maxBy(count).

                each(allFields, new Debug("#### device with max count"));



        return topology.build();

    }

  private void output(ResultSet resultSet, PrintStream out)

      throws SQLException {

    final ResultSetMetaData metaData = resultSet.getMetaData();

    final int columnCount = metaData.getColumnCount();

    while (resultSet.next()) {

      for (int i = 1;; i++) {

        out.print(resultSet.getString(i));

        if (i < columnCount) {

          out.print(", ");

        } else {

          out.println();

          break;

        }

      }

    }

  }

  private static CSVReader openCsv(File file) throws IOException {

    final Reader fileReader;

    if (file.getName().endsWith(".gz")) {

      final GZIPInputStream inputStream =

          new GZIPInputStream(new FileInputStream(file));

      fileReader = new InputStreamReader(inputStream);

    } else {

      fileReader = new FileReader(file);

    }

    return new CSVReader(fileReader);

  }

    public static PhysProj create(final RelNode input,

        final List<RexNode> projects, RelDataType rowType) {

      final RelOptCluster cluster = input.getCluster();

      final RelMetadataQuery mq = RelMetadataQuery.instance();

      final RelTraitSet traitSet =

          cluster.traitSet().replace(PHYSICAL)

              .replaceIfs(

                  RelCollationTraitDef.INSTANCE,

                  new Supplier<List<RelCollation>>() {

                    public List<RelCollation> get() {

                      return RelMdCollation.project(mq, input, projects);

                    }

                  });

      return new PhysProj(cluster, traitSet, input, projects, rowType);

    }

  public void checkCollation(

      String expression,

      String expectedCollationName,

      SqlCollation.Coercibility expectedCoercibility) {

    for (String sql : buildQueries(expression)) {

      RelDataType actualType = getColumnType(sql);

      SqlCollation collation = actualType.getCollation();



      assertEquals(

          expectedCollationName, collation.getCollationName());

      assertEquals(expectedCoercibility, collation.getCoercibility());

    }

  }

public static void assertArrayEqual(

   String message, Object[] expected, Object[] actual) {

   Joiner joiner = Joiner.on(' ');

   String strExpected = expected == null ? null : joiner.join(expected);

   String strActual = actual == null ? null : joiner.join(actual);

       assertEquals(message, strExpected, strActual);

}

    public Connection createConnection() throws SQLException {

      final Properties info = new Properties();

      for (Map.Entry<String, String> entry : map.entrySet()) {

        info.setProperty(entry.getKey(), entry.getValue());

      }

      Connection connection =

          DriverManager.getConnection("jdbc:calcite:", info);

      for (ConnectionPostProcessor postProcessor : postProcessors) {

        connection = postProcessor.apply(connection);

      }

      return connection;

    }

    public SSLContextBuilder loadTrustMaterial(

            final File file,

            final char[] storePassword,

            final TrustStrategy trustStrategy) throws NoSuchAlgorithmException, KeyStoreException, CertificateException, IOException {

        Args.notNull(file, "Truststore file");

        final KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());

        final FileInputStream instream = new FileInputStream(file);

        try {

            trustStore.load(instream, storePassword);

        } finally {

            instream.close();

        }

        return loadTrustMaterial(trustStore, trustStrategy);

    }

    public void testRequestHttp11HostHeaderPresent() throws Exception {

        final HttpContext context = new BasicHttpContext(null);

        final BasicHttpRequest request = new BasicHttpRequest("GET", "/", HttpVersion.HTTP_1_1);

        request.setHeader(HttpHeaders.HOST, "blah");

        final RequestValidateHost interceptor = new RequestValidateHost();

        interceptor.process(request, context);

    }

    public Object getDeclaredField(Class targetClass, String name, Object target)

        throws Exception

    {

        if (System.getSecurityManager() != null)

        {

            Actions actions = (Actions) m_actions.get();

            actions.set(Actions.GET_FIELD_ACTION, targetClass, name, target);

            try

            {

                return AccessController.doPrivileged(actions, m_acc);

            }

            catch (PrivilegedActionException e)

            {

                throw e.getException();

            }

        }

        else

        {

            Field field = targetClass.getDeclaredField(name);

            field.setAccessible(true);



            return field.get(target);

        }

    }