I had a List that had around 70000 objects in it and I needed only the first 15000. I was about to create a new empty array list and iterate 15000 times over the current one in order to get a smaller list. That would have been a mess.

I searched a bit and realized there was an easier (and I’m hoping it’s more efficient) way to reduce the size of a list.

//templist has 70000 objects in it

tempList.subList(15000 – 1, tempList.size()-1).clear();

//templist now has the first 15000 objects in it

//15000 – 1 because the positions start from 0

 

On Google Appengine I needed to fetch multiple objects, the key to which is present with me. I tried using PersistenceManager#getObjectsById(Collection) method and passed a list of keys to it. But that threw an exception. On further probing I realized this is not how #getObjectsById works.

There might be other ways of doing it but this is how I’ve done it :

List list = new ArrayList();

for(Key key : <iterate-over-list-of-keys>){

list.add(persistenceManager.newObjectIdInstance(<class-name-here>, key));

}

Collection objects = persistenceManager.getObjectsById(list);

Hopefully this helps you use the getObjectsById method in JDO on google appengine.

I’ve been using Gson from quite some time now. It’s a Java library developed by Google that is used to convert JSON to Java objects and vice versa. You can read more about Gson here.

I came across this json string which I had to convert into a Map. Here’s how you do it:

Type type =

 new TypeToken<Map<String, String>>(){}.getType();

Map<String, String> map =

 gson.fromJson("{'key1':'123','key2':'456'}", type);

Hope that helps you convert a json string into a java Map.

Cookies come as part of the HttpServletRequest object.  The below code should help you retrieve cookie values that you have set on a client’s browser.

Cookie[] cookies = servletRequest.getCookies();

if (cookies != null) {
 for (Cookie cookie : cookies) {
   if (cookie.getName().equals("cookieName")) {
     //do something

     //value can be retrieved using #cookie.getValue()

    }

  }

}

While trying to compile my java class files with the 1.6 java compiler, I came across an error message that read :

“no unique maximal instance exists for type variable U with upper bounds U”

The weird thing was that the file compiled just fine in eclipse!

On further probing I realized it’s a javac bug (check the bug here)

Here’s the workaround -

Bug Scenario :

public class SomeObject {

<U extends SomeObject> U foo1() throws Exception {

SomeObject obj = new SomeObject();
return obj.foo1();
}

}

Solve this way :

public class SomeObject {

<U extends SomeObject> U foo1() throws Exception {

SomeObject obj = new SomeObject();
return obj.<U>foo1();
}
}

I know this may be trivial for many people but then it can be pretty confusing for new bees (pssst.. in the beginning me too used to be confused between overloading and overriding)

OVERRIDING – when you extend a class and write a method in the derived class which is exactly similar to the one present in the base class, it is termed as overriding.

Example:

public class BaseClass{

public void methodToOverride()

{

//Some code here

}

}

public class DerivedClass extends BaseClass{

public void methodToOverride()

{

//Some new code here

}

}

As you can see, in the class DerivedClass, we have overridden the method present in the BaseClass with a completely new piece of code in the DerivedClass.

What that effectively means is that if you create an object of DerivedClass and call the methodToOverride() method, the code in the derivedClass will be executed. If you hadn’t overridden the method in the DerivedClass then the method in the BaseClass would have been called.

OVERLOADING -  when you have more than one method with the same name but different arguments, the methods are said to be overloaded.

Example:

public class OverLoadingExample{

public void add(int i, int j)

{

int k = i + j;

}

public void add(String s, String t)

{

int k = Integer.parseInt(s) + Integer.parseInt(t);

}

}

As you can see in the example above, we have the same method add() taking two parameters but with different data types. Due to overloading we can now call the add method by either passing it a String or int

Time to explore the ‘final‘ keyword.

When you use the keyword ‘final’ with a variable declaration, the value stored inside that variable cannot be changed come what may!!

So suppose you do this :

final int i =10;

After this, nowhere in your code can you change the value of ‘i’ i.e. ‘i’ will always have a value ’10′ .

So i = 11; //will give you a compile time error.

Now, suppose you did not initialize the final integer ‘i’ while declaring it.

final int i;

Can you assign any value to this variable now?

Yes, you definitely can. But only once!

So,

final int i;

i = 10; //This is fine

i = 11; //Compiler error

Now that was the core stuff about ‘final’ . Let’s learn a bit more in detail about it.

The ‘final’ keyword can be used for a class declaration or method declaration.

What happens when you use ‘final’ for a class declaration?

A: You cannot have a sub class of a class declared final i.e. No other class can extend this class.

What happens when you declare a method as final?

A: Simply put, the method cannot be overridden.

Can you override a method(Not declared as ‘final’) present inside a final class?

A: Obviously Not. Since there’s no way to extend a class declared final there’s no way of overriding its methods!

What happens when I declare a method inside a class as both ‘private’ and ‘final’ ?

A: Making a class both ‘private’ and ‘final’ makes the ‘final’ keyword redundant as a private method cannot be accessed in its sub class. But hey, you’ll be able to declare a method of the same name as in the base class if the method has been made private in the base class. But then that doesn’t mean you’re overriding the method. You’re simply declaring a new method in the sub class.

Note: You cannot make an ‘abstract’ class or method as ‘final’ because an ‘abstract’ class needs to be extended which will not be possible if you mark it as ‘final’!

I found this article on ‘final’ worth reading:

http://www.ibm.com/developerworks/java/library/j-jtp1029.html

int a[] = {1,2,3,4,5};

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

{

System.out.println(“Value: “+a[i]);

}

This is so 1.4!!!

Here’s how you do it with the new and enhanced for loop :

for(int b: a)

{

System.out.println(“Value :”+b);

}

To make it easy for you to understand how to interpret the above condition, read it as follows:

” for each int b in a…..iterate”

Basically what you have to do is – To the left of the colon in the for loop declare the datatype that is present inside the array and to the right of the colon write the name of the array.

The above ‘for’ loop will iterate as many times as there are elements in the array ‘a’. At every iteration int b will have the value of the next element.

In simple terms its like this:

for(int b: a) will internally expand like this : for(int i=0;i<a.length;i++){int b=a[i];}

You can use this for loop for iterating over type collections too.

Example :

List<MyObject> al = new ArrayList();

//Create an Object of some class you want to put into the arraylist.

MyObject myObject = new MyObject();

MyObject myObject1 = new MyObject();

al.add(myObject);

al.add(myObject1);

for(MyObject o : al)

{

System.out.println(“Object hashcode is “+o.hashCode());

}

In my post ‘Difference between String and StringBuffer/StringBuilder’ I told you stuff like String object is immutable( meaning the value stored in the object cannot be changed) and that when you perform operations such as concat or replace, internally a new object is created to hold the result.

Below is a simple example that will make you believe that what I said about String object is indeed true!

String s = “Let’s test”;

s.concat(” if the String object is IMMUTABLE”);

System.out.println(s);

s = s.concat(” if the String object is IMMUTABLE”);

System.out.println(s);

The output of the above code will be:

Let’s test

Let’s test if the String object is IMMUTABLE

That’s all people! The above piece of code proves that String is immutable and hence the results of operations like concat etc. should be stored into a new object.

Now get out of that bad habit of using String objects to perform operations on strings. With StringBuilder(introduced in J2Se 5.0), you can perform those very append and other such operations more efficiently.

Scene 1: typical coder…. using the same old String object to perform append operations.

String s = “Hello”;

s = s + ” World”;

system.out.println(s);

I agree it’ll give you “Hello World”, but fella…. let’s be different from the rest and think about making the code more efficient.

Enter Scene 2.

StringBuilder sb = new StringBuilder(“Hello”);

sb.append(” World”);

system.out.println(sb);

well… thats it!! You’ll get your “Hello World” but in a more efficient way