query to website

[eternalLearner]

i am writing an client application that connects to the server and then sends data to server.
but, the problem is that i get a java.net.Connec tException: Connection refused error.
The code i have written is :

//package bdn;
/*  The java.net package contains the basics needed for network operations. */
import java.net.*;
/* The java.io package contains the basics needed for IO operations. */
import java.io.*;
/** The SocketClient class is a simple example of a TCP/IP Socket Client.
 *
 */
 
public class SocketClient {
     public static void main(String[] args) {
        /** Define a host server */
        //find the ip address by ping cmd in unix
        String host = "211.65.63.147";
        /** Define a port */
        int port = 8080;
 
        StringBuffer instr = new StringBuffer();
        String TimeStamp;
        System.out.println("SocketClient initialized");
 
        try {
          /** Obtain an address object of the server */
          InetAddress address = InetAddress.getByName(host);
          /** Establish a socket connetion */
          Socket connection = new Socket(address, port);
          /** Instantiate a BufferedOutputStream object */
          BufferedOutputStream bos = new BufferedOutputStream(connection.
              getOutputStream());
 
          /** Instantiate an OutputStreamWriter object with the optional character
           * encoding.
           */
          OutputStreamWriter osw = new OutputStreamWriter(bos, "US-ASCII");
 
        }
        catch (Exception g) {
        System.out.println("Exception: " + g);
            }
 
    }
 
 
}
 

please let me know wat could be the problem.

[JosAH]

@chaarmann
That's not how Java memory allocation works; Java keeps a simple heap which is a contiguous chunk of memory; all objects are allocated next to each other until all memory is used; either another chunk of memory is allocated from the OS or the garbage collector is fired up.

This scenario makes memory allocation as cheap as can be and all sorts of object pooling etc. merely hinder than help the garbage collector nowadays. (google for "Java garbage collection" and you'll find the discussions).

The garbage collector applies a "generation scavenging" strategy, i.e. lots of objects in Java just live for a short while (e.g. local objects) and only some of them survive the first (small) collection phases. They are copied to an 'eden' space where they won't be affected by those small garbage collection phases. Only when all else fails (maximum heap size has been reached and no more memory could be collected) a full garbage collection is started that also checks the 'eden' space.

C and C++ use a much more naive approach and they don't move the allocated chunks of memory around so they have to maintain some form of a linked list of free/allocated memory. That can cause fragmentation but Java doesn't suffer from it.

Several containers (StringBuilder, ArrayList etc.) anticipate on the allocation of more memory by allocating (a bit) more memory than is strictly needed so they can use that memory in the near future. Strings don't do that, they're immutable and catenating Strings over and over again is a very inefficient operation.

As a rule of thumb: don't try to help the garbage collector; it knows how to do its job. Memory allocation is as fast as can be; constructors simply initialize/modify this already allocated memory.

kind regards,

Jos

[chaarmann]

And the String data itself? Isn't it copied over to the new memory location every time? Or does String use an internal array of allocated memory chunks, so that a string must not be linear in memory?

Jos, so what do you think in this case, how much times is it faster? On a scale from "not measurable percentage" to "many times"?
(If I write "new StringBuilder(1 0000)" instead of "new StringBuilder() " for an total average of 7000 characters loaded which are added line by line ?)

[JosAH]

@chaarmann
Most of the time the char buffers are copied over. An exception to the rule is the substring() method; the newly created String shares the buffer with the original String. If you read the source code of that class (see the src.zip file in your JDK installation) you'll see that the String class plays a few tricks with the StringBuffer class as well ...

@chaarmann
Of course preallocating a large enough buffer will be faster than simply incrementing the buffer over and over again; you don't have to copy the data in the buffer over and over again. otoh, 7000 characters isn't that much ...

kind regards,

Jos

[eternalLearner]

hi, thanks for all the inputs
I did as suggested, but the code still doesnot work.
Am I posting the query in incorrect format ??
the site is up now,