How to make Sitemap or Sitemap Generator

People always search on google to generate sitemap for own website. There are two popular versions of a site map. An XML Sitemap is a
structured format that a user doesn't need to see, but it tells the
search engine about the pages in a site, their relative importance to
each other, and how often they are updated. HTML sitemaps are designed
for the user to help them find content on the page, and don't need to
include each and every subpage.
Here, I will not give information how to make sitemap but I will teach you how to make your own sitemap generator, So Web Developers can easily make sitemap.

Step 4:
Save all files in one folder and open Sitemap.html in browser. Done.
Now your own sitemap generator is ready to make sitemap for your website.
If any query or problem, free to ask via comment.
Note: Don't use above code to publish on website or blog.

A filter is an object that is used to perform filtering
tasks such as conversion, log maintain, compression, encryption and
decryption, input validation etc. I'm not going to discuss about Java filter tutorial or javax filter tutorial here, there are many sites and books provide good tutorial for how to use java servlet filter in application.One common problem to exclude css, javaScript or any image and icon content with Java Filter in Java Web Application. Its a particular issue when during authentication via filter in java web application. Here I explain how to out from problem with java filter in java web application.

For example if we want to exclude css which in use with before authentication or home page accessible without even being logged in, we can add below code to resolve the issue.

So this is the easy way to make pages or contents becomes accessible without even being logged in with Java Filter in Java Web application
If anyone have any query or problem then free to ask via comment.

Java provides an extensive library of classes for managing input and
output of all forms of data. These classes are built around a stream model. You can think of a stream as a sequence of characters (in the case of textual data) or bytes (in the case of binary data) that can be accessed in order. A
stream can represent many different kinds of sources and
destinations, disk files, devices, other programs, etc. Streams support
many different kinds of data simple bytes, primitive data types,
localized characters, and objects. Some streams simply pass on data;
others manipulate and transform the data in useful ways. Data is
transferred to devices by streams. There is a better approach created to File handling using input output Stream in Java.

The goal of InputStream and OutputStream is to
abstract different ways to input and output: whether the stream is a
file, a web page, or the screen shouldn't matter. All that matters is
that you receive information from the stream. The java.io package contains a full set of Input and Output streams; Java programs use input streams to read data from some input source
and output streams to write data to some output source. Input and output
sources can be anything that can contain data: a file,
a string, or memory.

Java
views a file as a stream of bytes. File
ends with end-of-file marker or a specific byte number. File
as a stream of bytes associated with an object.Java also associates streams with
devices

System.in, System.out, and System.err

Streams can be redirected

You would typically first read from the input stream and then close it.
You can wrap the FileInputStream in another InputStream (or Reader). It
will be automatically closed when you close the wrapping stream/reader.

Java I/O Stream can be defined as below 3 types:

1. Byte Streams

Programs use byte streams to perform input and output of 8-bit bytes. Byte Streams classes are rooted as

InputStream

OutputStream

There are many byte stream classes for example FileInputStream and FileOutputStream. Following example shows how to use these classes to copy file.

void close() : Closes the file input and output streams and releases any system resources associated with the stream

2. Character Streams

The Java platform stores character values using Unicode conventions. Character stream I/O automatically translates this internal format to and from the local character set. A program that uses character streams in place of byte streams automatically adapts to the local character set. Root Classes for Character Streams

Reader Class

Writer Class (both are abstract)

Character streams are often “wrappers” for byte streams. The character stream uses the byte stream to perform the physical I/O, while the character stream handles translation between characters and bytes. FileReader, for example, uses FileInputStream, while FileWriter uses FileOutputStream.

Output or sink (destination) streams. Can write to these streams. Root classes of all output streams:

The OutputStream Class

The Writer Class

Control Flow of an I/O operation

Create a stream object and associate it with a datasource (data-destination)

Give the stream object the desired functionality through stream chaining while (there is more information)

read(write) next data from(to) the stream

close the stream

3. Buffered Streams

The examples shown so far use unbuffered I/O. This means each read or write request is handled directly by the underlying OS. This can make a program much less efficient, since each such request often triggers disk access, network activity, or some other operation that is relatively expensive. To reduce this kind of overhead, the Java platform implements buffered I/O streams. Buffered input streams read data from a memory area known as a buffer. Similarly, buffered output streams write data to a buffer. A program can convert an unbuffered stream into a buffered stream using the wrapping.

ExampleThere are four buffered stream classes used to wrap unbuffered streams:

BufferedInputStream

BufferedOutputStream (create buffered byte streams )

BufferedReader

BufferedWriter (create buffered character streams )

Flushing Buffered Streams

It often makes sense to write out a buffer at critical points, without waiting for it to fill. This is known as flushing the buffer. To flush a stream manually, invoke its flush method. The flush method is valid on any output stream, but has no effect unless the stream is buffered. Some buffered output classes support autoflush, specified by an optional constructor argument. When autoflush is enabled, certain key events cause the buffer to be flushed. For example, an autoflush PrintWriter object flushes the buffer on every invocation of println or formatCopyLine Example

If you want to upload a file to another computer, SCP is an excellent way to go. And if you want to do it from within a Java program, your best bet is to use the JSch library from JCraft. They've implemented the SSH protocol purely in Java, and it works splendidly. I've written a nice little class that encapsulates the action of sending a file.

The constructor takes a host, a username, and a password. The sendFile() method takes a source filename and a destination filename. It returns true if the upload was successful, false if it failed.

I developed it in Netbeans, and in order to use JSch, the first step is to download the JAR and add it as a library in your project. (When I first tried it, I downloaded the ZIP instead, and added the source to my project; this works, but it's not necessary to compile this library along with your project unless you plan to edit it. I didn't.)

Most of the code in this class is taken from the ScpTo example included in the ZIP file. I recommend reading it. Something to pay close attention to, however, is the SSH known_hosts file. Their example file doesn't take this into account, so if you just run their code, you get an unknown host exception and it doesn't work. So be sure to include the following:

Inner class, also called Nested class, is a non-static class which is defined inside another class. Inner classes are nothing but classes that are defined within other classes. The nesting is a relationship between classes, not objects.
They may be defined as public, protected, private, or with package access. They may only be used "in the context" of the containingclass (outer class, or enclosing class), unless they are marked as static

Java inner classes have feature that makes them richer and more useful. An object of an inner class has an implicit reference to the outer class object that instantiated it. Through this pointer, it gains access to any variable of the outer object. Only static inner classes don’t have this pointer. It is actually invisible when we write the code, but compiler takes care of it. Inner classes are actually a phenomenon of the compiler and not the JVM.

Inner Classes:

The outer class (the class containing the inner class) can instantiate as many number of inner class objects as it wishes, inside it’s code.

If the inner class is public & the containing class as well, then code in some other unrelated class can as well create an instance of the inner class.

No inner class objects are automatically instantiated with an outer class object.

If the inner class is static, then static inner class can be instantiated without an outer class instance, otherwise, the inner class object must be associated with an instance of the outer class.

Inner class code has free access to all elements of the outer class object that contains it, by name (no matter what the access level of the elements is), if the inner class has a varible with same name then the outer class’s variable can be accessed.

There are two more types of inner classes, i.e local inner classes & anonymous inner classes. The local inner class are defined within a method. Anonymous inner classes are also defined with in a method but have no name.

Local Inner Classes:

Local classes are never declared with an access specifier (that is, public or private). Their scope is always restricted to the block in which they are declared.

Local classes have a great advantage: they are completely hidden from the outside world.

They can not only access the instance variables but local variables of the method (in which they are defined) as well, but the local varible has to be declared final.

Anonymous Inner Classes:

When using local inner classes, you can often go a step further. If you want to make only a single object of this class, you don’t even need to give the class a name.
Such a class is called an anonymous inner class. Usually the inner class extend some interface or extend other class.

Here, SuperType can be an interface, such as ActionListener; then, the inner class implements that interface. Or SuperType can be a class; then, the inner class extends that class.

An anonymous inner class cannot have constructors because the name of a constructor must be the same as the name of a class, and the class has no name. Instead, the construction parameters are given to the superclass constructor. In particular, whenever an inner class implements an interface, it cannot have any construction parameters.

It is recommended to refrain from using them as many programmers find too many anonymous classes hard to read.

Static Inner Classes:

Static members of the outer class are visible to the static inner class, what ever their access level be.

Non-static members of the outer class are not available, because there is not instance of the outer class.

An inner class may not have static members unless the inner class is itself marked as static.

Sometimes static nested class are not refered to as inner class at all, as they don’t require outer classes instance.

A static inner class is just like any other inner class, but it dose not have the reference to its outer class object that generated it.