5/27/2012

All about arrays in java

  •  Arrays are way to store a list of items. Each slot of an array holds an individual element, and you can place into or change the contents of those slots as you need to.
  • Arrays can contain any type of element value(primitive types or objects), but you cant store different types in single array. You can have array of integers, or arrays of string.
  • To create an array in Java, you use three steps :
  1.        Declare a variable to hold the array. 
  2.        Create a new array object and  assign it to the array variable.
  3.        Store things in that array. 

Declaring array variables:
  • The first step in creating an array is creating an variable that will hold the array, just as you would any other variable.
  • Array variables indicate the type of object the array will hold and the name of the array, followed by empty square brackets [].
  • Following are the examples of Array declarations:
                int values[];
                float cost[];
                String months[];
  • There is another way to declare the array allowed in java as shown below:
                String[] names;
                int[] numbers;

Creating array object:
         The second step is to create an array object and assign it to that variable. There are two ways to do this :
  • using new
  • Directly initializing the contents of that array
The first way is to use the new operator to create new instance of an array:
      int[] values=new values[10];
This will creates anew array of int with size10.
  • When you create a new array object using new, you must indicate how many slots that array will hold.
  • You can create & initialize array at same time. Instead of using new to create the new array object, enclose the elements of the array inside braces, separated by commas:
                   int[] values={1,2,3,4,5};
  • Each of the elements inside the braces must be of the same type as the variable that holds that array.
  • An array the size of the number of elements you've included will be automatically created for you.
Accessing array elements:
  • Once you have array with an initial values, you can test and change the values in each subscript of that array. To get a value stored within an array, use the array subscript expression:
                      arrayname[subscript];
  • The arrayname is the name of array. The subscript is index of array elements stored in array. Array subscript starts with 0. So an array with 10 elements has 10 array elements accessed using subscript 0 to 9.
  • Note that all array subscripts are checked to make sure that they are inside the boundaries of the array. Note the following two statements, for example:
                       String[] arr=new String[10];
                       arr[10]="Ashish";
  • A program with that last statement in it produces acompiler error at that linewhen you try to compile it. The array stored in arr has size as 10, the element at subscript 10 doesn't exist, and java compiler will check for that.
  • If the array subscript calculated  at run-time & ends up outside the boundaries of the array, the java interpreter also produces an error.
Changing array elements:
  • To assign a particular value array slot, merely put an assignment statement after the array access expression:
                            values[2]= 45;
                            months[3]="March";

Example of arrays:
//program of sorting of array
class IntSorting
{
         public static void main(String args[])
        {
                  int num[]={55,40,80,65,01,71};
                  int n=num.length;
                  System.out.print("Give list as :");
                  for(int i=0 ; i<n ; i++)
                          System.out.print(" "+num[i]);
                  System.out.println("\n");

                  for(int i=0; i<n ; i++)
                  {
                          for(int j=i+1; j<n; j++)
                          {
                                   if(num[i]>num[j])
                                    {
                                              int temp=num[i];
                                              num[i]=num[j];
                                              num[j]=temp;
                                    }
                          }
                  }

                  System.out.print("Sorted list: ");
                  for(int k=0; k<num.length; k++)
                          System.out.print(" "+num[k]);
                  System.out.println("\n");
        } 
}

Output:
Given list: 55 40 80 65 1 71
Sorted list: 1 40 55 65 71 80

5/23/2012

How to print contents of JFrame in java

easywayprogramming.com How to print contents of jframe in java
How to print contents of jframe in java?

Many developers found it difficult to print contents of jframe in java.
Following example shows how to do it.

print.java

import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.PrintJob;
import java.awt.Toolkit;
import java.awt.Color;

import javax.swing.JFrame;
import java.util.Properties;

public class print extends JFrame
{
      PrintCanvas my_canvas = new PrintCanvas();

      public print()
      {
        add("Center", my_canvas);
        setSize(500, 500);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setTitle("Ashish Wagh");
        setVisible(true);
        String name = "Ashish Wagh";

        Properties properties = new Properties();
        PrintJob pj = Toolkit.getDefaultToolkit().getPrintJob(print.this, name, properties);
        if (pj != null)
        {
              my_canvas.printAll(pj.getGraphics());
              pj.end();
        }
      }

      public static void main(String args[])
      {
        print p= new print();
      }
}

class PrintCanvas extends Canvas
{
  public void paint(Graphics g)
  {
    Dimension size = getSize();
    int width = size.width;
    int height = size.height;
    int x1 = (int) (width * 0.1);
    int x2 = (int) (width * 0.9);
    int y1 = (int) (height * 0.1);
    int y2 = (int) (height * 0.9);

    g.setColor(Color.YELLOW);
    g.fillRect(x1, y1, x2 - x1, y2 - y1);
    g.setColor(Color.GREEN);
    g.drawRect(x1, y1, x2 - x1, y2 - y1);
    g.drawOval(x1, y1, x2 - x1, y2 - y1);
    g.setColor(Color.RED);
    g.drawLine(x1, y1, x2, y2);
    g.drawLine(x2, y1, x1, y2);
    g.setColor(Color.BLACK);
    String text = "Ashish!";
    text += text;
    text += text;
    g.drawString(text, x1, (int) ((y1 + y2) / 2));
    g.drawString("Ashish",(int)(width/2)-(width/20), (int)(y1+(y2/4)));
    g.drawString("Ashish",(int)(width/2)-(width/20), (int)(y1+((3*y2)/4)));
    g.dispose();
  }
}

5/22/2012

socket programming java basic classic example

easywayprogramming.com Socket programming in java basic classic example

Here is the classic example of socket programming in java.
GreetingSever.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread
{
       private ServerSocket serverSocket;
       Socket server;

       public GreetingServer(int port) throws IOException, SQLException, ClassNotFoundException, Exception
       {
          serverSocket = new ServerSocket(port);
          serverSocket.setSoTimeout(180000);
       }

       public void run()
       {
           while(true)
          {
               try
               {
                  server = serverSocket.accept();
                  DataInputStream din=new DataInputStream(server.getInputStream());
                  DataOutputStream dout=new DataOutputStream(server.getOutputStream());

                  dout.writeUTF("server: -i am greeting server");
                  dout.writeUTF("server:- hi! hello client");

                  System.out.println(din.readUTF());
                  System.out.println(din.readUTF());
              }
             catch(SocketTimeoutException st)
             {
                   System.out.println("Socket timed out!");
                  break;
             }
             catch(IOException e)
             {
                  e.printStackTrace();
                  break;
             }
             catch(Exception ex)
            {
                  System.out.println(ex);
            }
          }
       }
      
       public static void main(String [] args) throws IOException, SQLException, ClassNotFoundException, Exception
       {
              //int port = Integer.parseInt(args[0]);
              Thread t = new GreetingServer(6066);
              t.start();
       }
}

GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = "localhost";
      int port = 6066;
      try
      {
         System.out.println("Connecting to " + serverName
                             + " on port " + port);
         Socket client = new Socket(serverName, port);

         System.out.println("Just connected to "
                      + client.getRemoteSocketAddress());

        DataInputStream in=new DataInputStream(client.getInputStream());
        System.out.println(in.readUTF());
        System.out.println(in.readUTF());

         DataOutputStream out =
                       new DataOutputStream(client.getOutPutStream());

         out.writeUTF("Hello from "
                      + client.getLocalSocketAddress());
         out.writeUTF("client: hello to server")

         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

**Important notes:
       in greeting client server-name should be "localhost" if client and server are running oh same machines.
       If server and client are on different machines then in client we write a server-name i.e. computer_name of machine on which server is running.
       port number defined on client & server should be same. that means client is connecting to port on server.
       port number on client and server should be greater than 1023 (port  > 1023), because ports 0 to 1023 are well known ports, are used for specific purpose.  

Now we see running process
1.  open command promt or jcreator.
     Compile GreetingServer.java file.
     If no error, then run GreetingServer class.

2. now open another command promt or jcreator
    compile GreetingClient.java file
    if no error, then run GreetingClient class.

see what happens!!!!!!!!!

click here: Socket programming in java theory

5/18/2012

Socket Programming in Java: Basics Theory

 easywayprogramming.com socket programming in java basics theory    

       Hi guys, socket programming in java founds difficult to many peoples. I tried to show it in simple way, so peoples can understand it. First we will see some basic theory.
   
       There are two communication protocols that we can use for socket programming.
                  1. TCP/IP Communication (Stream communication)
                  2. UDP/IP Communication (Datagram communication)

Datagram Communication:
       The datagram communication protocol, known as UDP (user datagram protocol), is a connectionless protocol, meaning that each time you send datagrams, you also need to send the local socket descriptor and the receiving socket's address. As you can tell, additional data must be sent each time a communication is made.

Stream Communication:
       The stream communication protocol known as TCP(transfer communication protocol), i a connection oriented protocol. In order to do communication over the TCP protocol, a connection must first be established between the pair of sockets. While one of the sockets listens for a connection request (server), the other asks for a connection (client). Once two sockets have been connected, they can be used to transmit data in both (or either one of the) directions.
        Now we focus on stream communication.

Socket:
       Socket is one end-point of two way communication channel between two programes that are running on network. A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent. It is like end-point of tunnel or pipe-line.The java.net package provides two classes--Socket and ServerSocket--that implement the client side of the connection and the server side of the connection, respectively.

 Server: A server runs on a specific computer and has a socket that is bound to a specific port number. The server just waits, listening to the socket for a client to make a connection request.

 Client: The client knows the hostname of the machine on which the server is running and the port number on which the server is listening. To make a connection request, the client request to the server on the server's machine and port. The client also needs to identify itself to the server so it binds to a local port number that it will use during this connection. This is usually assigned by the system.





If everything goes well, the server accepts the connection. Upon acceptance, the server gets a new socket bound to the same local port and also has its remote endpoint set to the address and port of the client. It needs a new socket so that it can continue to listen to the original socket for connection requests while tending to the needs of the connected client. On the client side, if the connection is accepted, a socket is successfully created and the client can use the socket to communicate with the server.

Example: Socket programming in java: basic example