Hello, this is Jayeon.

Today, we'll look into the definition and characteristics of JCF.

What is JCF?

JCF stands for Java Collections Framework. It refers to a collection of classes that provide a standardized way to easily and effectively handle a large number of data. In other words, it implements data structures for storing data and algorithms for processing data as classes in a structured way. Here, Collections can be thought of as a set or group of data.

Framework vs Library

A framework can be defined as 'a collection of classes and interfaces that cooperate to solve a specific software problem' and it is not a completed application, but a task that the programmer needs to complete. On the other hand, a library is a collection of simple tools that can be used.

To explain the difference between the two in more detail, a framework controls the overall flow and users write the necessary code within it, while a library is used by users to create the overall flow.

Background of JCF Introduction

Before the introduction of JCF, the standardized way of grouping (Collection) Java objects was Arrays, Vectors, and Hashtables, and these Collections had no common interfaces. Therefore, even if the purpose of using these Collections was the same, they had to be defined separately. In addition, each Collection used different methods, syntax, and constructors, making it easy for developers to be confused when using them.

// Java program to demonstrate 
// why collection framework was needed 
import java.io.*; 
import java.util.*; 
  
class CollectionDemo { 
  
    public static void main(String[] args) 
    { 
        // Creating instances of the array, 
        // vector and hashtable 
        int arr[] = new int[] { 1, 2, 3, 4 }; 
        Vector v = new Vector(); 
        Hashtable h 
            = new Hashtable(); 
  
        // Adding the elements into the 
        // vector 
        v.addElement(1); 
        v.addElement(2); 
  
        // Adding the element into the 
        // hashtable 
        h.put(1, "geeks"); 
        h.put(2, "4geeks"); 
  
        // Array instance creation requires [], 
        // while Vector and hastable require () 
        // Vector element insertion requires addElement(), 
        // but hashtable element insertion requires put() 
  
        // Accessing the first element of the 
        // array, vector and hashtable 
        System.out.println(arr[0]); 
        System.out.println(v.elementAt(0)); 
        System.out.println(h.get(1)); 
  
        // Array elements are accessed using [], 
        // vector elements using elementAt() 
        // and hashtable elements using get() 
    } 

As you can see in the code above, the purpose of simply inserting elements, finding elements and printing them is the same, but the syntax used is different. For example, when inserting an element, vector uses addElement() and Hashtable uses put().

Therefore, Java developers designed a common interface to solve this problem, which is the Java Collections Framework that we are introducing today. As a reference, Vector and Hashtabls became legacy classes and are no longer used today.

Advantages of JCF

(1) Code reuse is easy.

(2) It provides high-performance implementations of data structures and algorithms, which improves program performance and quality.

(3) It provides interoperability between unrelated APIs.

(4) It reduces the time required to learn and design new APIs.

(5) It promotes software reuse. This is because new data structures using JCF can be reused and for the same reason, new algorithms can be created using objects using JCF.

Summary

So far, we have looked into the meaning of JCF, why it was introduced, and what its advantages are.

Next time, we will discuss the hierarchical structure of JCF.