Starting from r03, Guava releases may be found in the central Maven repository.


You may include Guava by adding the following dependency to your POM:

    &lt;dependency&gt;
        &lt;groupId&gt;com.google.guava&lt;/groupId&gt;
        &lt;artifactId&gt;guava&lt;/artifactId&gt;
        &lt;version&gt;23.0&lt;/version&gt;
    &lt;/dependency&gt;

*Note: the above version number may be outdated when you read this. To know the latest available version, you may look [here][1]*

Version updated on 19th Oct 2017.

  [1]: http://repo2.maven.org/maven2/com/google/guava/guava/

[Bintray&#39;s JCenter][1] is a superset of Maven Central as includes libraries from various repositories. Here&#39;s [Google Guava][2].

You can click on &quot;Set me up!&quot; to get the instructions on how to configure your build tool to resolve from JCenter and on the &quot;i&quot; on a jar file to get the dependency declaration for your build tool. 

You can also become a watcher to get notifications on new versions. 


  [1]: https://bintray.com/bintray/jcenter
  [2]: https://bintray.com/bintray/jcenter/com.google.guava:guava/view

[mvnrepository][1] is your friend.  It has an index of maven repository space with maven, ivy and other details about artifacts.  


  [1]: http://mvnrepository.com/

You can find all guava maven repositories here:
http://mvnrepository.com/artifact/com.google.guava

Find latest guava(version 17.0) maven repositories &lt;http://mvnrepository.com/artifact/com.google.guava/guava/17.0&gt;

Guava: Google Core Libraries For Java: https://mvnrepository.com/artifact/com.google.guava/guava

I&#39;m developing an API with many identically named methods that just differ by signature, which I guess is fairly common. They all do the same thing, except that they initialize various values by defaults if the user does not want to specify. As a digestible example, consider

    public interface Forest
    {
      public Tree addTree();
      
      public Tree addTree(int amountOfLeaves);
      
      public Tree addTree(int amountOfLeaves, Fruit fruitType);
      
      public Tree addTree(int amountOfLeaves, int height);
      
      public Tree addTree(int amountOfLeaves, Fruit fruitType, int height);
    }

The essential action performed by all of these methods is the same; a tree is planted in the forest. Many important things users of my API need to know about adding trees hold for all these methods.

Ideally, I would like to write one Javadoc block that is used by all methods:

      /**
       * Plants a new tree in the forest. Please note that it may take
       * up to 30 years for the tree to be fully grown.
       *
       * @param amountOfLeaves desired amount of leaves. Actual amount of
       * leaves at maturity may differ by up to 10%.
       * @param fruitType the desired type of fruit to be grown. No warranties
       * are given with respect to flavour.
       * @param height desired hight in centimeters. Actual hight may differ by
       * up to 15%.
       */

In my imagination, a tool could magically choose which of the @params apply to each of the methods, and thus generate good docs for all methods at once.

With Javadoc, if I understand it correctly, all I can do is essentially copy&amp;paste the same javadoc block five times, with only a slightly differing parameter list for each method. This sounds cumbersome to me, and is also difficult to maintain.

Is there any way around that? Some extension to javadoc that has this kind of support? Or is there a good reason why this is not supported that I missed?

Javadoc reuse for overloaded methods

I have a long set of comparisons to do in Java, and I&#39;d like to know if one or more of them come out as true. The string of comparisons was long and difficult to read, so I broke it up for readability, and automatically went to use a shortcut operator `|=` rather than `negativeValue = negativeValue || boolean`.

    boolean negativeValue = false;
    negativeValue |= (defaultStock &lt; 0);
    negativeValue |= (defaultWholesale &lt; 0);
    negativeValue |= (defaultRetail &lt; 0);
    negativeValue |= (defaultDelivery &lt; 0);
I expect `negativeValue` to be true if any of the default&amp;lt;something&amp;gt; values are negative. Is this valid? Will it do what I expect? I couldn&#39;t see it mentioned on Sun&#39;s site or stackoverflow, but Eclipse doesn&#39;t seem to have a problem with it and the code compiles and runs.

---

Similarly, if I wanted to perform several logical intersections, could I use `&amp;=` instead of `&amp;&amp;`?

Shortcut &quot;or-assignment&quot; (|=) operator in Java

I am looking to find guava-libraries in maven repository.  It looks like guava is adding more features to google-collections library.

is guava-libraries available in maven repo?

<p>I am looking to find guava-libraries in maven repository.  It looks like guava is adding more features to google-collections library.</p>


The following compiles fine:

      Object o = new Object();
      System.out.println(o instanceof Cloneable);

But this doesn&#39;t:

      String s = new String();
      System.out.println(s instanceof Cloneable);

A compiler error is thrown.

What is the problem?

instanceof - incompatible conditional operand types

How do I convert a [list][1] of String into an [array][2]? The following code returns an error.

	public static void main(String[] args) {
		List&lt;String&gt; strlist = new ArrayList&lt;String&gt;();
		strlist.add(&quot;sdfs1&quot;);
		strlist.add(&quot;sdfs2&quot;);
		String[] strarray = (String[]) strlist.toArray();		
		System.out.println(strarray);
	}
Error:

    Exception in thread &quot;main&quot; java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
    	at test.main(test.java:10)


  [1]: https://docs.oracle.com/javase/8/docs/api/java/util/List.html
  [2]: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html

Converting List&lt;String&gt; to String[] in Java

I have a program which i have myself written in java, but I want to test method execution times and get timings for specific methods. I was wondering if this is possible, by maybe somehow an eclipse plug-in? or maybe inserting some code?

	
I see, it is quite a small program, nothing more than 1500 lines, which would be better a dedicated tool or `System.currentTimeMillis()`?

How can i benchmark method execution time in java?

A friend of mine was asked the following question today at interview for the position of software developer:

Given two string `s1` and `s2` how will you check if `s1` is a **rotated** version of `s2` ?

***Example:*** 

If `s1 = &quot;stackoverflow&quot;` then the following are some of its rotated versions:

    &quot;tackoverflows&quot;
    &quot;ackoverflowst&quot;
    &quot;overflowstack&quot;

where as `&quot;stackoverflwo&quot;` is ***not*** a rotated version.

The answer he gave was:&lt;br&gt;
&gt;Take `s2` and find the longest prefix that is a sub string of `s1`, that will give you the point of rotation. Once you find that point, break `s2` at that point to get `s2a` and `s2b`, then just check if `concatenate(s2a,s2b) == s1`

It looks like a good solution to me and my friend. But the interviewer thought otherwise. He asked for a simpler solution. Please help me by telling how would you do this in `Java/C/C++` ?

Thanks in advance.

Interview question: Check if one string is a rotation of other string

To continue to question further I&#39;m more interested in blogs, websites who once in a while release a tutorial, tip or best-practice on the topics I mentioned. For ex : 
http://net.tutsplus.com/ is very good website to follow if you wanna learn about or upgrade your knowledge about CSS, HTML, Javascript, PHP .. Is there a website like this for Java and related technologies?

what are good blogs to read relating java, spring, hibernate, maven?

What is the difference between `dependencyManagement` and `dependencies`?
I have seen the docs at Apache Maven web site.
It seems that a dependency defined under the `dependencyManagement` can be used in its child modules without specifying the version. 

For example:

A parent project (Pro-par) defines a dependency under the `dependencyManagement`:

    &lt;dependencyManagement&gt;
      &lt;dependencies&gt;
        &lt;dependency&gt;
          &lt;groupId&gt;junit&lt;/groupId&gt;
          &lt;artifactId&gt;junit&lt;/artifactId&gt;
          &lt;version&gt;3.8&lt;/version&gt;
        &lt;/dependency&gt;
     &lt;/dependencies&gt;
    &lt;/dependencyManagement&gt;

Then in the child of Pro-par, I can use the junit:

      &lt;dependencies&gt;
        &lt;dependency&gt;
          &lt;groupId&gt;junit&lt;/groupId&gt;
          &lt;artifactId&gt;junit&lt;/artifactId&gt;
        &lt;/dependency&gt;
     &lt;/dependencies&gt;

However, I wonder if it is necessary to define junit in the parent pom? Why not define it directly in the needed module?

Differences between dependencyManagement and dependencies in Maven

Artifacts from dependencies can be excluded by declaring an `&lt;exclusions&gt;` element inside a `&lt;dependency&gt;` But in this case it&#39;s needed to exclude an artifact inherited from a parent project. An excerpt of the POM under discussion follows:

&lt;!-- language: xml --&gt;

    &lt;project&gt;
      &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt;
      &lt;groupId&gt;test&lt;/groupId&gt;
      &lt;artifactId&gt;jruby&lt;/artifactId&gt;
        &lt;version&gt;0.0.1-SNAPSHOT&lt;/version&gt;
        &lt;parent&gt;
            &lt;artifactId&gt;base&lt;/artifactId&gt;
            &lt;groupId&gt;es.uniovi.innova&lt;/groupId&gt;
            &lt;version&gt;1.0.0&lt;/version&gt;
        &lt;/parent&gt;
    
        &lt;dependencies&gt;      
            &lt;dependency&gt;
                &lt;groupId&gt;com.liferay.portal&lt;/groupId&gt;
                &lt;artifactId&gt;ALL-DEPS&lt;/artifactId&gt;
                &lt;version&gt;1.0&lt;/version&gt;
                &lt;scope&gt;provided&lt;/scope&gt;
                &lt;type&gt;pom&lt;/type&gt;
            &lt;/dependency&gt;
        &lt;/dependencies&gt;
    &lt;/project&gt;

`base` artifact, depends on  `javax.mail:mail-1.4.jar`, and `ALL-DEPS` depends on another version of the same library. Due to the fact that `mail.jar` from `ALL-DEPS` exist on the execution environment, although not exported, collides with the `mail.jar` that exists on the parent, which is scoped as `compile`.

A solution could be to rid off mail.jar from the parent POM, but most of the projects that inherit base, need it (as is a transtive dependency for log4j). So What I would like to do is to simply **exclude parent&#39;s library from the child project**, as it could be done if `base` was a dependency and not the parent pom:

&lt;!-- language: xml --&gt;

    ...
        &lt;dependency&gt;
            &lt;artifactId&gt;base&lt;/artifactId&gt;
            &lt;groupId&gt;es.uniovi.innova&lt;/groupId&gt;
            &lt;version&gt;1.0.0&lt;/version&gt;
            &lt;type&gt;pom&lt;type&gt;
            &lt;exclusions&gt;
              &lt;exclusion&gt;
                 &lt;groupId&gt;javax.mail&lt;/groupId&gt;
                 &lt;artifactId&gt;mail&lt;/artifactId&gt;
              &lt;/exclusion&gt;
            &lt;/exclusions&gt;
        &lt;/dependency&gt;
    ...


Is there anyway to exclude artifacts inherited from a parent POM?

Is there a Maven plugin that allows you to check if there are newer versions of dependencies available in the repository?

Say, you are using dependency X with version 1.2. Now a new version of X is released with version 1.3. I&#39;d like to know, based on the dependencies used in my project, which dependencies have newer versions available.

Maven check for updated dependencies in repository

I&#39;m a beginner at Maven and I&#39;ve played with it from a command line point of view a little, so now I was trying to use it in Eclipse; I installed the m2eclipse plugin to do so.

But I&#39;m stumped from the very beginning! Apparently I&#39;ve missed a bit of terminology somewhere along the line. I can&#39;t keep track of all these new Maven terms... **What is a Maven Project, and what is a Maven Module?** These are my options when creating a new project in the Maven category in Eclipse.

Maven &quot;Module&quot; vs &quot;Project&quot; (Eclipse, m2eclipse plugin)

I have a Java primitive type at hand:

    Class&lt;?&gt; c = int.class; // or long.class, or boolean.class

I&#39;d like to get a *default value* for this class -- specifically, the value is assigned to fields of this type if they are not initialized. E.g., `0` for a number, `false` for a boolean.

Is there a generic way to do this? I tried this:

    c.newInstance()

But I&#39;m getting an `InstantiationException`, and not a default instance.

Getting default value for primitive types

I am going through the code which uses `Predicate` in Java. I have never used `Predicate`. Can someone guide me to any tutorial or conceptual explanation of `Predicate` and its implementation in Java?

Predicate in Java

I didn&#39;t find such a multimap construction... When I want to do this, I iterate over the map, and populate the multimap. Is there an other way?


    final Map&lt;String, Collection&lt;String&gt;&gt; map = ImmutableMap.&lt;String, Collection&lt;String&gt;&gt;of(
                &quot;1&quot;, Arrays.asList(&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;c&quot;));
    System.out.println(Multimaps.forMap(map));

    final Multimap&lt;String, String&gt; expected = ArrayListMultimap.create();
    for (Map.Entry&lt;String, Collection&lt;String&gt;&gt; entry : map.entrySet()) {
        expected.putAll(entry.getKey(), entry.getValue());
    }
    System.out.println(expected);

The first result is `{1=[[a, b, c, c]]}` but I expect `{1=[a, b, c, c]}`



How to create a Multimap&lt;K,V&gt; from a Map&lt;K, Collection&lt;V&gt;&gt;?

I have had a quick scan of the [Guava API][1] and the new collection types it provides(`Multimap` and `BiMap` for example appear useful) and I am thinking of including the library in the project(s) I work on.

However, I also have a reticence to include libraries willy-nilly if they are of no great benefit and learning the features wastes valuable time.

Have you included the Guava library in your project and has it proved useful in any unexpected way? Would you always use it in the future? What has been its main benefit/time saver? What are its hidden features?


  [1]: https://google.github.io/guava/releases/snapshot/api/docs/

The Guava library: What are its most useful and/or hidden features?

[Apache Commons IO][1] has a nice convenience method [IOUtils.toString()][2] to read an `InputStream` to a String.

Since I am trying to move away from Apache Commons and to [Guava][3]: is there an equivalent in Guava? I looked at all classes in the `com.google.common.io` package and I couldn&#39;t find anything nearly as simple.

**Edit:** I understand and appreciate the issues with charsets. It just so happens that I know that all my sources are in ASCII (yes, ASCII, not ANSI etc.), so in this case, encoding is not an issue for me.


  [1]: http://commons.apache.org/io
  [2]: http://commons.apache.org/io/api-release/org/apache/commons/io/IOUtils.html#toString%28java.io.InputStream%29
  [3]: http://code.google.com/p/guava-libraries/

Content Type	Original Author	Original Content on Stackoverflow
Question	mjlee	View Question on Stackoverflow
Solution 1 - Java	Etienne Neveu	View Answer on Stackoverflow
Solution 2 - Java	JBaruch	View Answer on Stackoverflow
Solution 3 - Java	Peter Kahn	View Answer on Stackoverflow
Solution 4 - Java	Sambhav Sharma	View Answer on Stackoverflow
Solution 5 - Java	jitendra.khedar	View Answer on Stackoverflow
Solution 6 - Java	David Soroko	View Answer on Stackoverflow

is guava-libraries available in maven repo?

Java Problem Overview

Java Solutions

Solution 1 - Java

Solution 2 - Java

Solution 3 - Java

Solution 4 - Java

Solution 5 - Java

Solution 6 - Java

Shortcut "or-assignment" (|=) operator in Java

Javadoc reuse for overloaded methods

Attributions