1.Need for Serializable interface:An object created in java may sometimes have to travel across the network to another remote network area.So in order to facilitate this, every collection object implements Serializable Interface.

​

To facilitate the above process, every object should implement Serializable interface.

2.Need for Cloneable Interface: After travelling across the network, the object may undergo unforeseen corruption,so they make a shallow copy of the object that and work on it to check for any corrupted data.

Cloneable Interface implements Clone() which makes a shallow copy of the object.This prevents the loss of time and data.So every collection class implements cloneable interface too.

​

My jargon is not up to the mark,i tried to answer at a low level to make it more comprehensible.

P.S:Correct me if i'm wrong

First of all, linked list is a part of data structure. You can implement it in any language like c/c++. Memory is a crucial resource, you know about it, right? simply, because every application ask for it.

So, let's say, there's a guy called 'X' who manage the memory and there's a programmer called 'Y'.

Now, let's hear the conversation carefully between both of them and at the end, you will definitely get what I'm trying to convey.

Y: Hey, what's up? Hope you are doing good. I want to store a list of integers(array) and maximum number of integers in this list will be 4. Can you please assign it into memory?

X: Ok, I need to give you contiguous block of memory of 16 bytes. Since, one block will take 4 bytes, so 4 blocks will take 16 bytes.

---------- After few months ----------

Y: Now, I want to store 5th element in the same array. So, can you please extend the same block of array?

X: Sorry, I didn't expect any extension. So, I can't give you memory because I've other variable next to your block.

Y: You can't do this to me because I need memory. So, what all options do I have?

X: You can give me new size and I will create new block of memory and copy all the previous elements in new block. This will cost you more.

Y: still sad :( because what if I need extension again in future, also I'm not using remaining portion of memory. I need solution.

So, the solution of this problem is LINKED LIST.

Now, this time, Y will ask to memory manager X for 1 unit of data at a time instead of array. For eg, to store 1,5,3,4, he will make separate request to first store 1, then 5, then 3 and so on.

Since, X will make separate request, he may or may not get adjacent memory. In this way, he will get disjoint non-contiguous block of memory. So, we need to link these blocks somehow and for that, we will store extra information with each block.

In one part of block, we will store value and in other part, we will store address of next block. In last block, we will store 0 which indicates end of list.

Reason to use linked list:

1. Cost of accessing elements: In array, it is O(1), while, in linked list, it is O(n).
2. Memory Requirement: In array, there may be unused memory but linked list needs extra memory and won't have unused memory.
3. Insertion and deletion operations are comparatively easy in linked list.
4. And most importantly, linked list is dynamic.

I hope you get your answer.

Image Source: Shweta Singh (श्वेता सिंह) .

Serialization in Java

Serialization in Java is a mechanism of writing the state of an object into a byte stream.

It is mainly used in Hibernate, RMI, JPA, EJB and JMS technologies.

The reverse operation of serialization is called deserialization.

Advantages of Java Serialization

It is mainly used to travel object's state on the network (which is known as marshaling).

java.io.Serializable

Serializable is a marker interface (has no data member and method). It is used to "mark" Java classes so that objects of these classes may get the certain capability. The Cloneable and Remote are also marker interfaces.

It must be implemented by the class whose object you want to persist.

The String class and all the wrapper classes implement the java.io.Serializable interface by default.

Let's see the example given below:

import java.io.Serializable; 
public class Student implements Serializable{ 
  int id; 
  String name; 
  public Student(int id, String name) { 
    this.id = id; 
    this.name = name; 
  } 
} 

In the above example, Student class implements Serializable interface. Now its objects can be converted into stream.

ObjectOutputStream class

The ObjectOutputStream class is used to write primitive data types, and Java objects to an OutputStream. Only objects that support java.io.Serializable interface can be written to streams.

Constructor

public ObjectOutputStream(OutputStream out) throws IOException {} 

creates an ObjectOutputStream that writes to the specified OutputStream.

Important Methods

Description

public final void writeObject(Object obj) throws IOException {} 

writes the specified object to the ObjectOutputStream.

public void flush() throws IOException {} 

flushes the current output stream.

public void close() throws IOException {} 

closes the current output stream.

Example of Java Serialization

In this example, we are going to serialize the object of Student class. The writeObject() method of ObjectOutputStream class provides the functionality to serialize the object. We are saving the state of the object in the file named f.txt.

import java.io.*; 
class Persist{ 
  public static void main(String args[])throws Exception{ 
    Student s1 =new Student(101,"ram"); 
    FileOutputStream fout=new FileOutputStream("f.txt"); 
    ObjectOutputStream out=new ObjectOutputStream(fout); 
    out.writeObject(s1); 
    out.flush(); 
    System.out.println("success"); 
  } 
} 
 
/* 
success 
*/ 

Please read carefully the LinkedList documentation.

Sure, in section “Method Summary” there is no method isEmpty().

But in section “Methods declared in class java.util.AbstractCollection” you can find it:

LinkedList doesn’t implement the isEmpty() function by it self but inherit it from AbstractCollection.

The implementation relies on the abstract method size() and looks like:

    public boolean isEmpty() { 
        return size() == 0; 
    } 

See

This is the Java 8 implementation but I think this doesn’t matter here.

So LinkedList provides a size() method and gets the isEmpty() method for free.

I presume this question is pertaining to the java programming language.

No, LinkedList is not thread safe or by default it is not synchronized in java.

LinkedList implements the List and Deque interfaces to have a doubly LinkedList implementation.

If multiple threads access a linked list concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more elements; merely setting the value of an element is not a structural modification.) This is typically accomplished by synchronizing on some object that naturally encapsulates the list. If no such object exists, the list should be "wrapped" using the Collections.synchronizedList method.

List list = Collections.synchronizedList(new LinkedList(...)); 

The ConcurrentLinkedQueue implementation is a default synchronized queue implementation using LinkedList

In Java, the Serializable interface is a marker interface that indicates that the objects of the class implementing it can be serialized. Serialization is the process of converting an object into a byte stream, which can be saved to a file or sent over a network. Deserialization is the process of reconstructing the object from the byte stream.

Here's the syntax for the Serializable interface:

javaCopy codeimport java.io.Serializable; 
 
public class MyClass implements Serializable { 
    // Class members and methods 
    // ... 
} 

In this example:

• MyClass is a class that implements the Serializable interface.
• The Serializable interface does not declare any methods; it acts as a marker to indicate that the class is intended to be serializable.

Here's a more detailed example:

javaCopy codeimport java.io.*; 
 
class Person implements Serializable { 
    private String name; 
    private int age; 
 
    public Person(String name, int age) { 
        this.name = name; 
        this.age = age; 
    } 
 
    public String getName() { 
        return name; 
    } 
 
    public int getAge() { 
        return age; 
    } 
} 
 
public class SerializationExample { 
    public static void main(String[] args) { 
        Person person = new Person("John Doe", 30); 
 
        // Serialization 
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.ser"))) { 
            out.writeObject(person); 
            System.out.println("Object has been serialized"); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
 
        // Deserialization 
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.ser"))) { 
            Person deserializedPerson = (Person) in.readObject(); 
            System.out.println("Object has been deserialized"); 
            System.out.println("Name: " + deserializedPerson.getName()); 
            System.out.println("Age: " + deserializedPerson.getAge()); 
        } catch (IOException | ClassNotFoundException e) { 
            e.printStackTrace(); 
        } 
    } 
} 

In this example:

• The Person class implements Serializable.
• An instance of Person is serialized to a file (person.ser) and then deserialized back into a new instance.
• Note the use of ObjectOutputStream for serialization and ObjectInputStream for deserialization.

It does.

Here is a simple JUnit test.

@Test 
void testLinkedList() { 
	List<String> list = new LinkedList<>(); 
	assertTrue(list.isEmpty()); 
	list.add("One"); 
	assertFalse(list.isEmpty()); 
} 

It passes.

Now if we look at the documentation

It does not list the method in the Method Summary section. However, if you scroll down you find

Methods declared in interface java.util.List

containsAll, equals, hashCode, isEmpty, iterator, listIterator, removeAll, replaceAll, retainAll, sort, subList

so there is an implementation somewhere. If we further look at its superclasses

java.lang.Object   
  java.util.AbstractCollection<E> 
    java.util.AbstractList<E> 
      java.util.AbstractSequentialList<E> 
        java.util.LinkedList<E> 

We find AbstractCollection has a definition for isEmpty(), which basically just checks size() == 0.

The size method is defined in the LinkedList class.

So this is a good example of Object-Oriented programming inheriting methods.

Reading docs usually can answer this type of questions.

List: List (Java Platform SE 8 )
Queue: Queue (Java Platform SE 8 )

So, in short:

When you create an object by using interface, you only have access to that interface's methods. If you create LinkedList as List<Something> list = new List<>(); you can only access methods List interface provides, but not the ones in Queue. List has a richer API, which makes sense because, unlike queue, it provides access to elements by their insertion order, while Queue only provides the head (depending on the type, it's either first or last element; they both have their respective iterators). That property allows you to insert and remove elements from specific places, get index of the wanted element or check whether List contains the given object.

Queue introduces only six methods - add (adds element to the queue), element (returns head, throws), offer (adds element if possible), peek (returns head, doesn't throw), poll (returns head and removes it from the queue, doesn't throw), remove (same as poll, throws). It's not the prettiest API, but it works. List has ~30 methods which you can look up in the docs.

What really matters is communicating the purpose. If you need a FIFO queue, declare it as a Queue, if you need a List then, well, declare it as a list.

I don’t program in Java, but our Plain English compiler uses general-purpose hashed “indexes” that are implemented with a combination of arrays and linked lists to keep track of type names, global variable names, and routine names (so we can find them quickly and easily when we need them later in the process of compiling). Maybe looking at that will give you some ideas.

Each index record points to an array of bucket records, where each bucket is the anchor for a doubly-linked list of refer (reference) records, like this (click to enlarge):

Storing the both the first and any overflow refers for each bucket in the same list simplifies and standardizes the code for finding any entry in the index.

Only three buckets are shown in the above diagram, but many more are typically used in real-life situations. These, for example, are the create statements we use for our compiler indexes:

Create the type index with 4027 [buckets].
Create the global index with 4027 [buckets].
Create the routine index with 7919 [buckets].

And this is the routine we use to hash the various names:

To get a bucket# given a string and an index:
Put the string's length into the bucket#.
If the bucket# is 0, exit.
Add 5381 to the bucket#.
Slap a substring on the string.
Loop.
Put the substring's first's target into a byte.
Lowercase the byte.
Put the bucket# into a number.
Shift the bucket# left 5 bits.
Add the number to the bucket#.
Add the byte to the bucket#.
Add 3 to the substring's first.
If the substring is blank, break.
Repeat.
Bitwise and the bucket# with the largest number.
Divide the bucket# by the index's bucket count giving a quotient and the bucket#.

It is reasonably simple, small and fast enough for our purposes. It is similar to Daniel J. Bernstein’s “djb2″ algorithm, but we hash only the first and every third byte of the string after the that.

Et voila!

It is a great structure where things gets added/removed to front/end of the list. That immediately gets into Stack/Queue.

LinkedList are literally great at Stack and Queue.

Now comes the problematic part — adding a node is HUGE operation.

HUGE. If we use abstraction as ArrayList then adding a node is superfast.

People tend to thing about [math]O(1) [/math], but that is terrible abstraction. There is actually some time that will be spent to add a node.

LinkedList is a the slowest structure to do so, UNLESS, of course the ArrayList is having a problem of space constraint, so expansion - and boom!

Now ArrayList is way more time consuming.

Reality, real life complexity management comes under performance tuning - which is ( I used to do that in D.E.Shaw & Co. ) definitely non O(.) . It is actually if at all [math]\Theta(.) [/math]and actually not even that.

Copybook definition of efficiency is a terrible mess.

Linked lists are handy if you need to insert items in between or remove items.

With an array, you would need to move lots of elements ‘to the right’ to make room for a new element in the middle or ‘to the left’ to fill the hole if you remove an element in the middle. That is: if you insist that the original order is maintained. Else you could add new elements to the end of a std::vector. Removing a value in the middle (if order doesn’t matter) can be done by overwriting it with the last element and then making the vector one smaller. That would still have complexity O(1), constant time. Note: you may have to delete the element that is removed or free it. The latter is uncommon, cause then you would mix C style malloc with C++ STL.

Linked lists are often sorted in some way and you want to maintain the proper order at all times. Although they allow for fast removal and insertion, they have poor cache performance due to poor space locality: all nodes can be ‘anywhere’ in memory, they are not at neat consecutive locations. Also, the pointers to the next node (and previous node in case of double linked list) take extra memory. Thus for small lists it is better to use a std::vector or an array. Perhaps you can first build the vector or array and sort when you are done adding all items.

Traditionnaly we use ArrayList implementation of List in Java most of the time, which provide O(1) access to n element because they are backed by arrays. There is a downside though, when it is time to expand the ArrayList, a new expanded internal array is created and contents are copied over from previous array.

On the other hand, LinkedList doesn’t have this problem, inserting at tail is always one step, though index based access or insertion will be slower, worst case scenario order of (n/2) depending whether internal implementation start traversing from tail or head. Other advantage is using LinkedList as a Queue which is useful in many scenarios.

At the end it depends on your usecase which implement of List is suitable for your algorithm.

I worked primarily in Lisp (with a bit of C now and then) for about ten years starting in the mid-1980s. In Lisp, a linked list is the basic data structure, and there are lots of clever things you can do with them. They become trees if the elements themselves are lists. But in Java or other languages I mostly use now, I hardly ever care about how a list is implemented. In Java, the ArrayList generally has better performance unless you frequently need to insert or remove items in the middle of the list. But in many of those cases you should be asking whether a sorted list or tree would be better to start with.