Search Java Programs

Thursday, January 7, 2010

Running a Java Program

Math Class Methods

do while Loops

Compound Interest Program

for Loops

Simple Averaging Program

Conditional Operators

else if Statement

Nested if Statements

Constructors

Many Methods and Instances

Use Methods with Parameters

Using Multiple Classes

While Loop Statements

Switch Statement

Logical Operators

If Statement

Increment Operators

Math Operators

Building a Basic Calculator

Getting User Input

1 - Installing the JDK

Classes and Methods

The general class and main() method

public class {
type instace_variable1;
type instace_variable2;
type method_name1(parameters){ }
type method_name2(parameters){ }
public static void main(String[] args) {
System.out.println("Java");
}
}
Classes Introduction

A class is declared by the use of class keyword. The general form of a class is given above. The class with the main method initiates execution of a program. There can be classes created without main method. These classes will act as a user defined data types or the type definition.
The data or variables, defined within a class are called instance variables.The code is contained within methods. Collectively, the methods and variables defined within a class are called members of the class. In most of the cases, the instance variables are acted upon and accessed by methods defined for that class. Thus, it is the methods that determine how a class' data can be used.
Variables defined within a class are called instance variables because each instance of the class contains its own copy of these variables. All methods have the same general form as the main(). However, most methods will not be specified as static or public. Java classes do not need to have a main() method.
Classes can contain static member subroutines, as well as static member variables. For example, the System class contains a subroutine named exit. In a program, of course, this subroutine must be referred to as System.exit. Calling this subroutine will terminate the program. You could use it if you had some reason to terminate the program before the end of the main routine.
The subroutine call statement might look like "System.exit(0);" or "System.exit(1);". exit(0) means the program ends normally. Any other value means the program exits because of error detection.

A Simple class

Here is a class called as Box that defines three variables : length, width and height. Currently class box does not contains any methods. In this case we have created a new data type called Box.
class Box {
int length;
int width;
int height;
}
This class can be used in other classes for declaring member objects.

For example:

public class BoxDemo {
public static void main(String args[]) {

Box mybox = new Box();
// creating object and calling the constructor
mybox.width = 5; // assignment of values
mybox.height = 10;
mbox.length = 20;

System.out.println( "The height of the box is " +mybox.height);
System.out.println( "The width of the box is " +mybox.width);
System.out.println( "The length of the box is " +mybox.length);
}
// Printing values by calling System package methods

} //end of the class

Constructors

Constructor name is class name. A constructors must have the same name as the class its in. Default constructor.
If you don't define a constructor for a class, a default parameterless constructor is automatically created by the compiler. The default constructor calls the default parent constructor (super()) and initializes all instance variables to default value.
Default constructor is created only if there are no constructors. If you define any constructor for your class, no default constructor is automatically created.

Differences between methods and constructors.
There is no return type given in a constructor signature. The value is this object itself so there is no need to indicate a return value. There is no return statement in the body of the constructor.
The first line of a constructor must either be a call on another constructor in the same class (using this), or a call on the superclass constructor (using super() ). If the first line is neither of these, the compiler automatically inserts a call to the parameterless super class constructor.
These differences in syntax between a constructor and method are sometimes hard to see when looking at the source. It would have been better to have had a keyword to clearly mark constructors as some languages do.

this(...) Calls another constructor in same class. Often a constructor with few parameters will call a constructor with more parameters, giving default values for the missing parameters. Use this to call other constructors in the same class.

super(...) Use super to call a constructor in a parent class. Calling the constructor for the superclass must be the first statement in the body of a constructor. If you are satisfied with the default constructor in the superclass, there is no need to make a call to it because it will be supplied automatically.

Parameterised Constructors

Constructors and methods differ in three aspects of the signature: modifiers, return type, and name. Like methods, constructors can have any of the access modifiers: public, protected, private, or none. Unlike methods, constructors can take only access modifiers. Therefore, constructors cannot be abstract, final, native, static, or synchronized.

The return types are very different too. Methods can have any valid return type, or no return type, in which case the return type is given as void. Constructors have no return type, not even void.

Finally, in terms of the signature, methods and constructors have different names. Constructors have the same name as their class; by convention, methods use names other than the class name. If the Java program follows normal conventions, methods will start with a lowercase letter, constructors with an uppercase letter. Also, constructor names are usually nouns because class names are usually nouns; method names usually indicate actions

Garbage Collection

The name "garbage collection" implies that objects no longer needed by the program are "garbage" and can be thrown away. A more accurate and up-to-date metaphor might be "memory recycling." When an object is no longer referenced by the program, the heap space it occupies can be recycled so that the space is made available for subsequent new objects. The garbage collector must somehow determine which objects are no longer referenced by the program and make available the heap space occupied by such unreferenced objects. In the process of freeing unreferenced objects, the garbage collector must run any finalizers of objects being freed.
New objects are allocated, and unreferenced objects are freed such that free portions of heap memory are left in between portions occupied by live objects. Requests to allocate new objects may have to be filled by extending the size of the heap even though there is enough total unused space in the existing heap. This will happen if there is not enough contiguous free heap space available into which the new object will fit. On a virtual memory system, the extra paging (or swapping) required to service an ever growing heap can degrade the performance of the executing program. On an embedded system with low memory, fragmentation could cause the virtual machine to "run out of memory" unnecessarily.
A second advantage of garbage collection is that it helps ensure program integrity. Garbage collection is an important part of Java's security strategy. Java programmers are unable to accidentally (or purposely) crash the Java virtual machine by incorrectly freeing memory.

The finalise() method

Before an object is garbage collected, the runtime system calls its finalize() method. The intent is for finalize() to release system resources such as open files or open sockets before getting collected. Your class can provide for its finalization simply by defining and implementing a method in your class named finalize(). Your finalize() method must be declared as follows:

protected void finalize () throws throwable
This class opens a file when its constructed:

class OpenAFile {
FileInputStream aFile = null;
OpenAFile(String filename) {
try {
aFile = new FileInputStream(filename);
}
catch (java.io.FileNotFoundException e) {
System.err.println("Could not open file " + filename);
}
}
}


To be well-behaved, the OpenAFile class should close the file when its finalized. Here's the finalize() method for the OpenAFile class:

protected void finalize () throws throwable {
if (aFile != null) {
aFile.close();
aFile = null;
}
}


The finalize() method is declared in the java.lang.Object class. Thus when you write a finalize() method for your class you are overriding the one in your superclass. Overriding Methods talks more about how to override methods.

If your class's superclass has a finalize() method, then your class's finalize() method should probably call the superclass's finalize() method after it has performed any of its clean up duties. This cleans up any resources the object may have unknowingly obtained through methods inherited from the superclass.

protected void finalize() throws Throwable {
. . .
// clean up code for this class here
. . .
super.finalize();
}


Overloading Methods

Overloading is used in the standard Java classes. The System.out.println method accepts multiple parameter lists. This sample code snippet is valid:

System.out.println("Builder.com");

as is this one:

int test = 2; System.out.println(test);

Both code snippets compile and execute with no problems. The println method has been designed to accept varying parameters, so overloading is applicable beyond constructors.

Recursion
It is the central Simply put, recursion is when a function calls itself. That is, in the course of the function definition there is a call to that very same function. At first this may seem like a never ending loop, or like a dog chasing its tail. It can never catch it. So too it seems our method will never finish. This might be true is some cases, but in practise we can check to see if a certain condition is true and in that case exit (return from) our method

class Factorial {
int fact(int n) {
int result;
if ( n ==1) return 1;
result = fact (n-1) * n;
return result;
}
}

public class Recursion {
public static void main (String args[]) {
Factorial f =new Factorial();
System.out.println(“Factorial of 3 is “ + f.fact(3));
System.out.println(“Factorial of 3 is “ + f.fact(4));
System.out.println(“Factorial of 3 is “ + f.fact(5));
}
}

The output from this program is shown here:
Factorial of 3 is 6
Factorial of 4 is 24
Factorial of 5 is 120
The final Keyword
A variable can be declared as final. Doing so prevents its contents from being modified. This means we have to initialize the variable when it is declared. Keyword final in java is similar to "const" in c / c++. The value of final variables will remain same through out the application.

For example:
final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;

Arrays Revisited
Arrays are aslo implemented as objects. Hence there is a special array attribute to tell the size of the array, that is teh number of elements that an array can hold is found in its length instance variable. All arrays have this variabe, and it will always hold the size of the array. Here is a program that demonstrates this property.

public class Length {
int l;
public static void main(String args[]){
int n1[] = new int[10];
int n2[] = {3, 5, 7, 1, 8, 99, 44, -10);
int n3[] = { 4, 3, 2, 1);

System.out.println(“Length of n1 is “ + n1.length);
System.out.println(“Length of n2 is “ + n1.length);
System.out.println(“Length of n3 is “ + n1.length);
}

The output from this program is shown here:
Length of n1 is 10
Length of n2 is 8
Length of n3 is 4

Classes and Methods

Methods are subroutines or functions used to perform a task with or modify an object. Since classes are the base of all java structures all functions must be included in a class. There are three levels of visibility for methods, public, private, and protected. Public methods are accessible from anywhere in the program, private methods are only accessible from within the class, and protected methods are available inside the class and any subclasses in the same package. If no access is specified class and package have access but not subclasses. A method must declare the type of return value or void for no return value.

Classes may also contain class wide variables with the same public, private, protected attributes. It is usually considered best practice to set the class variables as private and use public getter and setter routines to access the variable. This is called encapsulation.
Include GetterSetterEx.java

class GetterSetterEx {
private int i = 0;
private String s = "string";

public int getI() {
return(this.i);
}

public void setI(int i) {
this.i = i;
}

public String getS() {
return(s);
}

public boolean isSLongerThanI() {
if (s.length() > i) {
return(true);
} else {
return(false);
}
}

public GetterSetterEx(int i, String s) {
this.i = i;
this.s = s;
}
}

This class simply demonstrates how to create private class variables and getter/setter methods for each. The variables are declared as private and can only be accessed from this class. When using this class in conjunction with any other class you must use the get and set methods for each variable. In addition to the getters and setters we added another simple method to determine if the string is longer than the value of the integer.

Also notice the final method in the class, and how it has the same name as the class. This is called the constructor and is called whenever the class is initialized. This method expects 2 values to be passed at initialization. The constructor method should always be declared public with no return type or void declaration. Multiple constructors can exist with different parameter types that handle initialization differently.

Importing Packages
Java uses the import command to include external packages to extend the functionality of your application. The Java Runtime Environment (JRE) includes a large set of libraries to build your application with ranging from network socket connections to graphical user interface (GUI) building packages. Before a package or class, such as the one we previously created can be used, they must be imported. The import statement comes at the beginning of the .java file and should be outside the class declaration.

Conditionals and Loops

Conditionals perform the core logic switching of your application. Java uses the standard and, or operator syntax for comparison, and (&&) ... or (||) Operators along with equals (==) and not equals (!=). Unlike some languages you cannot compare strings with == or != except to check nullness. To check if 2 strings are equal check stringOne.equals("String to match").

if ... else

The if ... else statement is the base of the conditional.
Create a new file IfElseEx1.java

class IfElseEx1 {
public static void main(String[] args) {
if (args[1].contains(args[0])) {
System.out.println(args[0] + " is contained in " + args[1]);
} else {
System.out.println(args[0] + " is not contained in " + args[1]);
}
}
}
The if ... else example checks if the first argument passed is contained in the second argument passed.
Create a new file IfElseEx2.java
class IfElseEx2 {
public static void main(String[] args) {
String s = "this is a string";
if (s == null) {
System.out.println("String is null");
} else if (s.equals("will this match?")) {
System.out.println("I guess it did");
} else if (s.equals("this is a string")) {
System.out.println("this is a string matched");
} else {
System.out.println("no match");
}
}
}


This example demonstrates how to find if two strings match. Strings also have a method equalsIgnoreCase that is a non case sensitive match. Also demonstrated is the if else syntax that allows an if statement to have multiple conditions to attempt to match.

switch ... case

The switch statement is a conditional similar to if, but if used to check one variable for a series of conditions. The switch checks the variable against each case. A case is terminated by a break statement. If a break statement is missing the code will fall through and execute the next case until a break statement is reached. The default case is executed if no other case checks match
Create the file SwitchCaseEx.java

class SwitchCaseEx {
public static void main(String[] args) {
switch(args.length) {
case 1:
System.out.println("One command line argument");
break;
case 2:
System.out.println("Two command line arguments");
break;
case 3:
System.out.println("Three command line arguments");
break;
case 4:
System.out.println("Four command line arguments");
break;
case 5:
System.out.println("Five command line arguments");
break;
default:
System.out.println("0 or more than 5 command line arguments");
break;
}
}
}

This isn't the most creative way to show a switch statement but it clearly displays the syntax. In instances where a switch can replace an if/else block it probably should as this is much cleaner, easier to read code. Switch statements in Java can only be applied to integer style types (byte, short, int), char, and enumerated types (not covered in this tutorial). If there are no command line arguments passed or more than 5 command line arguments the default case is called, otherwise the proper case statement is executed.

Loops

Loops are used to conditionally repeat blocks of code. Java implements the common while, for, and foreach loops along with a do ... while loop.

While

Repeat the block of code while the condition is true.
Create the file WhileEx.java

class WhileEx {
public static void main(String[] args) {
int i = 0;
int j;
while (i <= 5) {
j = i * 5;
System.out.println(i + " * 5 = " + j);
i++;
}
}
}

This loop will iterate 6 times. When executing a while statement like this it is important to remember to increment the conditional variable.

do ... while

A while loop with the iterate conditional at the end of the loop block. Do while loops will always iterate once since the check is after the code block.
Create the file DoWhileEx.java

class DoWhileEx {
public static void main(String[] args) {
int i = 0;
int j;
do {
j = i * 5;
System.out.println(i + " * 5 = " + j);
i++;
} while (i <= 5);

}
}

This code performs exactly as with the While loop example. The only difference is that the conditional is checked after the code block is executed.

For

For loops are used to iterate through a loop a number of times. The iteration conditional in a for loop has 3 parts, the counter initialization, the conditional to check, the increment syntax. The increment syntax is executed each time through the loop.
Create the file ForEx.java

class ForEx {
public static void main(String[] args) {
int j;
for (int i=0; i < 10; i++) {
j = i * i;
System.out.println(i + " squared is: " + j);
}
}
}

This simple for loop squares the counter variable. Notice that even though the increment is listed at the top of the code it isn't executed until after the first iteration.

Foreach

Foreach loops are used to iterate through a list of values. In Java a foreach loop uses the for statement with different syntax to declare how to iterate.
Create the file ForeachEx.java
class ForeachEx {
public static void main(String[] args) {
String[] sArray = {"This", "is", "an", "array", "of", "strings" };
for (String s : sArray) {
System.out.println(s);
}
}
}


Loop through the array of strings displaying each to the screen.

Arrays, Strings and Other Common Types

Arrays

All primitive types can be turned into arrays. Arrays are simply indexed lists of the type in which they are initialized. Arrays are initialized by adding [] to the type when declaring the variable.
Create a file ArrayEx.java

class ArrayEx {
public static void main(String[] args) {
int[] iArr;
char cArr[] = {'F', 'a', 'k','e', 'S', 't', 'r', 'i', 'n', 'g'};

iArr = new int[4];
iArr[0] = 1;
iArr[1] = 10;
iArr[2] = 20;
iArr[3] = iArr[1] * iArr[2];
System.out.println(iArr.length);

System.out.println(cArr.length + " - " + cArr.toString());
}
}

First initialize an integer array and a character array. The character array is not a real string as the example will show. You need to use the String type explained next for that. Notice that the first index of the array is 0. So the integer array iArr has 4 indexes numbered 0-3.

Strings

Strings in Java are implemented through java.lang.String. java.lang.String provides a good interface for the storing and manipulation of string data.
Create the file StringEx.java

class StringEx {
public static void main(String[] args) {
String s = "new string";

System.out.println(s);
System.out.println("Length: " + s.length());
System.out.println("Number of words: " + s.split(" ").length);
}
}
Initialize a new String s with the value "new string" without the quotes. Print the string. Then print the length of the string. The split method accepts a string as an input and uses that to break the string into an array of strings. We then take the length of that array. In the example we split on a space and use that to calculate the number of words in the string.

Java variables

Command line variables provide a simple way for the user to pass data and manipulate the runtime of the application. Command line variables are space delimited and multi word strings need to be properly quoted or escaped. See your operating system or terminal documentation for exact syntax (usually surrounded with "" or before the space).
Create a new file CommandLineEx.java

class CommandLineEx {
public static void main(String[] args) {
System.out.println(args[0]);
}
}

This code functions exactly like HelloWorld.java except the printed string comes from the first argument passed to the program. All other options passed on the command line are ignored. See the for loop example for a more complete example of parsing command line variables.

Basic Variable Types

Java variables are typed and must be declared before use. Java has 8 primitive data types. A byte is an 8 bit signed integer with an allowable value between -128 and 127. A short is a 16 bit signed integer with an allowable value between -32738 and 32767. An int is a 32 bit signed integer with an allowable value between -2,147,483,648 and 2,147,483,647. A long is a 64 bit signed integer with an allowable value between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807.
Create file BasicDataIntEx.java

class BasicDataIntEx {
public static void main(String[] args) {
byte b = 5;
byte b2;
short s = 48;
short s2;
int i = 100;
int i2;
long l = 1000;
long l2;

i2 = i / b;
l2 = l * s;
System.out.println(i2);
}
}

First initialize 2 variables each of byte, short, int long types, and perform some math operations on the values and print. Math operations cannot be stored into byte or short types, but they can be used in mathmatical operations stored into int or long types.
Adjust BasicDataIntEx.java so the math operations and output are:

i++;
l--;
i+=10;
l-=100;

System.out.println(i2);
System.out.println(l2);
System.out.println(i);
System.out.println(l);

When an integer style variable is followed by ++ the variable is incremented, and -- it is decremented. If these statements happened to be part of an equation a = b++; a would contain the value of b before the incrementing. Also a = --b; a would be one less than the value of b, but b would remain unchanged. The code i += 10 is shorthand for i = i + 10; and the code l-=100 is similar shorthand for l = l - 100.

The rest of the Java primitive data types are, float which is a 32 bit single precision IEEE 754 floating point number. Double, a 64 bit single precision IEEE 754 floating point number. The char, a single 16 bit unicode character. And boolean which is the standard true/false boolean type.
Create the file FloatDoubleEx.java

class FloatDoubleEx {
public static void main(String[] args) {
float pi = 3.14f;
float r = 4f;
float c;

c=pi*(r*r);
System.out.println(c);
}
}
You might notice this is simply the formula to find the circumference of a circle. Floating point numbers should be denoted with a trailing f. Now change the variable types to double. Also change the trailing f to a d to denote double.
Create a file CharBooleanEx.java

class CharBooleanEx.java {
public static void main(String[] args) {
char a = "b";
boolean b = true;
}
}
We don't do much with these at this point but show you how to declare them.

Introduction To Java

What is Java?

Java is an open source object oriented programming language developed by Sun Microsystems. The Java language is commonly used to build a variety of client applications and web systems. Java has been growing in popularity and usage in the field since it's release, and the Java platform was designed to be cross platform compatible with the under the hood work done by the Java Runtime.

Basic Syntax

With Java everything is an object. Each object is represented by a class and is stored in a .java source file. Java programs are a collection of classes that work together.
Create a new file HelloWorld.java

class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
Before we can execute this, we must compile it. With Java you use the javac command to compile a java class. This will be the only place in this tutorial where we cover compiling as it's the same process for the entire tutorial.

$ javac HelloWorld.java
$ java HelloWorld
Hello World
The class should have the same name of the .java file. Functions in Java are commonly called methods. The method main is used as the function to call when the program is executed. Methods will be covered in detail later. Values passed to the program from the command line will be stored in the String array args. The System.out.println method is called and passed Hello World. System.out.println pushes to the display (STDOUT) the passed argument followed by a newline. All code blocks in Java are delimited with { }.

Working With Android Contacts

Introduction To Android Contacts

Learn to work with the Android contacts database. Basic knowledge of accessing SQLite in Android along with using Cursors is expected. See the Android SQLite and Cursor Article for more information. Google changed the contacts database moving from 1.x to 2.0 versions of Android. This tutorial will be broken into 3 sections. First covering accessing contacts in Android 2.0. The second page will deal with accessing the contacts in Android 1.6 and before. Third we'll glue it all together with a class that abstracts specific classes for each version and a set of classes to manage the data from the contact records.

Create a new project called TestContacts in Eclipse setup for Android 2.0.
Android Contact API For 2.0
Granting Access

Before an application can query the contact records access must be granted through the AndroidManifest.xml file stored in the root of the project. Add the following uses-permission belows the uses-sdk statement.

<uses-permission android:name="android.permission.READ_CONTACTS" />


Querying The Android Contact Database

Retrieving Contact Details

Basic contact information stored in Contacts table with detailed information stored in individual tables for normalization. In Android 2.0 to query the base contact records the URI to query is stored in ContactsContract.Contacts.CONTENT_URI.

package higherpass.TestContacts;

import android.app.Activity;
import android.content.ContentResolver;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.ContactsContract;

public class TestContacts extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
ContentResolver cr = getContentResolver();
Cursor cur = cr.query(ContactsContract.Contacts.CONTENT_URI,
null, null, null, null);
if (cur.getCount() > 0) {
while (cur.moveToNext()) {
String id = cur.getString(
cur.getColumnIndex(ContactsContract.Contacts._ID));
String name = cur.getString(
cur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
if (Integer.parseInt(cur.getString(cur.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER))) > 0) {
//Query phone here. Covered next
}
}
}
}
}

This application starts off as any other Android application. First create a ContentResolver isntance in cr. Then use the ContentResolver instance to query the database and return a Cursor with the contacts list. The query is perofrmed against the URI stored in ContactsContract.Contacts.CONTENT_URI. Next check if the cursor contains records and if so loop through them. The record ID field is stored in the id variable. This will be used as a where parameter later. Also the display name field is stored in the string name. For more details about working with cursors see Android Cursors Tutorial.

Phone Numbers

Phone numbers are stored in their own table and need to be queried separately. To query the phone number table use the URI stored in the SDK variable ContactsContract.CommonDataKinds.Phone.CONTENT_URI. Use a WHERE conditional to get the phone numbers for the specified contact.

 if (Integer.parseInt(cur.getString(
cur.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER))) > 0) {
Cursor pCur = cr.query(
ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
null,
ContactsContract.CommonDataKinds.Phone.CONTACT_ID +" = ?",
new String[]{id}, null);
while (pCur.moveToNext()) {
// Do something with phones
}
pCur.close();
}

Perform a second query against the Android contacts SQLite database. The phone numbers are queried against the URI stored in ContactsContract.CommonDataKinds.Phone.CONTENT_URI. The contact ID is stored in the phone table as ContactsContract.CommonDataKinds.Phone.CONTACT_ID and the WHERE clause is used to limit the data returned.

Email Addresses

Querying email addresses is similar to phone numbers. A query must be performed to get email addresses from the database. Query the URI stored in ContactsContract.CommonDataKinds.Email.CONTENT_URI to query the email address table.

Cursor emailCur = cr.query(
ContactsContract.CommonDataKinds.Email.CONTENT_URI,
null,
ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = ?",
new String[]{id}, null);
while (emailCur.moveToNext()) {
// This would allow you get several email addresses
// if the email addresses were stored in an array
String email = emailCur.getString(
emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA));
String emailType = emailCur.getString(
emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.TYPE));
}
emailCur.close();

As with the phone query the field names for the email table are also stored under ContactsContract.CommonDataKinds. The email query is performed on the URI in ContactsContract.CommonDataKinds.Email.CONTENT_URI and the WHERE clause has to match the ContactsContract.CommonDataKinds.Email.CONTACT_ID field. Since multiple email addresses can be stored loop through the records returned in the Cursor.

Notes

Custom notes can be attached to each contact record. As before these are stored in a separate table and are related based on the contact ID.

String noteWhere = ContactsContract.Data.CONTACT_ID + " = ? AND " + ContactsContract.Data.MIMETYPE + " = ?";
String[] noteWhereParams = new String[]{id,
ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE};
Cursor noteCur = cr.query(ContactsContract.Data.CONTENT_URI, null, noteWhere, noteWhereParams, null);
if (noteCur.moveToFirst()) {
String note = noteCur.getString(noteCur.getColumnIndex(ContactsContract.CommonDataKinds.Note.NOTE));
}
noteCur.close();

Notes are stored in the Android Contacts generic data table. When accessing specific data the WHERE clause will need 2 conditionals. First the standard contact ID, second a MIMETYPE for the data that is being requested. The Android SDK comes with a series of auto-generated variables that take care of this. Use the ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE variable to limit the query to note records. The data table URI is stored at ContactsContract.Data.CONTENT_URI. Finally the note field name is stored in ContactsContract.CommonDataKinds.Note.NOTE.

Postal Addresses

Android can store multiple postal addresses per contact. Addresses are also stored in the data table like notes and queried via the URI stored in ContactsContract.Data.CONTENT_URI. Similar to the notes query a MIMETYPE must be added to the WHERE conditional. Also in Android 2.0 the Address record was split into multiple fields containing different parts of the address (PO-Box, stree, city, region, postal code). In earlier versions of the Android SDK this was a free-form string storage.

String addrWhere = ContactsContract.Data.CONTACT_ID + " = ? AND " + ContactsContract.Data.MIMETYPE + " = ?";
String[] addrWhereParams = new String[]{id,
ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE};
Cursor addrCur = cr.query(ContactsContract.Data.CONTENT_URI,
null, where, whereParameters, null);
while(addrCur.moveToNext()) {
String poBox = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.POBOX));
String street = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.STREET));
String city = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.CITY));
String state = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.REGION));
String postalCode = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE));
String country = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY));
String type = addrCur.getString(
addrCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.TYPE));
}
addrCur.close();

This code is similar to the previous example. Notice the field names for the address pieces are stored in ContactsContract.CommonDataKinds.StructuredPostal.

Instant Messenger (IM)

The instant messenger query performs just as the notes and address queries. Important field names for IM related data are stored in ContactsContract.CommonDataKinds.Im.

String imWhere = ContactsContract.Data.CONTACT_ID + " = ? AND " + ContactsContract.Data.MIMETYPE + " = ?";
String[] imWhereParams = new String[]{id,
ContactsContract.CommonDataKinds.Im.CONTENT_ITEM_TYPE};
Cursor imCur = cr.query(ContactsContract.Data.CONTENT_URI,
null, imWhere, imWhereParams, null);
if (imCur.moveToFirst()) {
String imName = imCur.getString(
imCur.getColumnIndex(ContactsContract.CommonDataKinds.Im.DATA));
String imType;
imType = imCur.getString(
imCur.getColumnIndex(ContactsContract.CommonDataKinds.Im.TYPE));
}
imCur.close();

Organizations

The last part of the contact record to be covered is the Organizations data. The Android contact record can contain information about Employment, professional, and social memberships as well as roles and titles. These records are queried from the URI stored in ContactsContract.Data.CONTENT_URI. Important field names for the organization data are stored in ContactsContract.CommonDataKinds.Organization.


String orgWhere = ContactsContract.Data.CONTACT_ID + " = ? AND " + ContactsContract.Data.MIMETYPE + " = ?";
String[] orgWhereParams = new String[]{id,
ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE};
Cursor orgCur = cr.query(ContactsContract.Data.CONTENT_URI,
null, orgWhere, orgWhereParams, null);
if (orgCur.moveToFirst()) {
String orgName = orgCur.getString(orgCur.getColumnIndex(ContactsContract.CommonDataKinds.Organization.DATA));
String title = orgCur.getString(orgCur.getColumnIndex(ContactsContract.CommonDataKinds.Organization.TITLE));
}
orgCur.close();

Some More String Methods

Common String Methods

How To Compile A Java Program With Javac

Website Design by Mayuri Multimedia