Stack implemented as array - Data Structure

// Stack implemented as array
public class ArrayStack<T> {
     private T[] stack;
     private int numElements = 0; // points to slot after top element

     public ArrayStack(T[] s) { stack = s; }  

     public boolean emptyStack() { 
         return numElements == 0; }
   
     public T  top() {
         return stack[numElements-1];
       }

     public void push(T x) {
         stack[numElements] = x;
         numElements++;
       }
  
     public T pop() {
         numElements--;
         return stack[numElements];
      }

    public static void main(String[] args) {
       ArrayStack<Integer> s = new ArrayStack<Integer>(new Integer[100]);
       s.push(2);
       s.push(3);
       s.push(5);
       System.out.println(s.top());
       System.out.println(s.pop());
       System.out.println(s.pop());
       s.push(15);
       s.push(22);
       System.out.println(s.pop());
   }
}

[ Read More ]

Ordered array of ints with no repetition - Data Structure

public class OrderedArray {

   private int numElements = 0;
   private int[] elements;

// Constructor..Note: the caller has to provide the array of elements.
// This is because Java generics do not allow a call "elements = new T[100]".
//
   public OrderedArray(int[] elts) {
        elements = elts; }

   public int getNumElements() { return numElements; } 

   public int nth(int n) { // return the Nth element
       if (n < numElements) return elements[n]; else return -1; }
  
   public int first() { return nth(0); } 
   public int  last() { return nth(numElements-1); } 

//  search(X) returns the index where X is, if X is in the list.
//  Otherwise, it returns the index of the smallest number greater than X
   public int search(int x) {
       if (numElements==0) return 0;
       if (x <= first()) return 0;
       if (x > last()) return numElements;
       if (x == last()) return numElements-1;
       return search1(x,0,numElements-1); 
     }

// X is strictly between L and U.
   public int search1(int x,int l,int u) {
        if (u==l+1) return u;
        else {
           int m = (l+u)/2;
           if (x==elements[m]) return m;
           else if (x < elements[m]) return  search1(x,l,m);
           else return search1(x,m,u);
        }
     }

   public boolean inList(int x) {
       return (elements[search(x)]==x); }

   public void add(int x) {
      int i = search(x);
      if (elements[i] != x)  {
        for (int j = numElements; j>i; j--)
           elements[j]=elements[j-1];
        elements[i]=x;
        numElements++;
       }
     }

   public void delete(int x) {
      int i = search(x);
      if (elements[i] == x) {
        for (int j=i+1; j < numElements; j++)
          elements[j-1] = elements[j];
        numElements--;
      }
    }


   public String toString() {
      String s = "[";
      for (int i=0; i < numElements; i++)
         s = s + " " + elements[i];
      return s+"]";
   }

   public static void main(String[] args) {
      OrderedArray l = new OrderedArray(new int[100]);
      l.add(31);
      l.add(41);
      l.add(59);
      l.add(26);
      l.add(53);
      l.add(58);
      l.add(37);
      l.delete(53);
      System.out.println(l.toString());
      System.out.println(l.search(2));
      System.out.println(l.search(26));
      System.out.println(l.search(53));
      System.out.println(l.search(54));
      System.out.println(l.search(195));
}
}

[ Read More ]

Array Resize in Java

Creates a new array and reallocate an array with a new size, and copies the contents of the old array to the new array.

//  oldArray  is  the old array, to be reallocated.
// newSize is  the new array size.
// return   type is a new array with the same contents.

public Object resizeArray (Object oldArray, int newSize) {
   int oldSize = java.lang.reflect.Array.getLength(oldArray);
   Class elementType = oldArray.getClass().getComponentType();
   Object newArray = java.lang.reflect.Array.newInstance(
         elementType,newSize);
   int preserveLength = Math.min(oldSize,newSize);
   if (preserveLength > 0)
      System.arraycopy (oldArray,0,newArray,0,preserveLength);
   return newArray;
}

[ Read More ]

Array to Map

This method will convert data type Array to Map in key value pair.

String[][] countries = { { "United States", "New York" }, { "United Kingdom", "London" },
        { "Netherland", "Amsterdam" }, { "Japan", "Tokyo" }, { "France", "Paris" } };
 
    Map countryCapitals = ArrayUtils.toMap(countries);

[ Read More ]

Splitting the Elements in One Array and Adding into Map based on Length in Second Array

The Code Snippet will split the array elements using Comma and add this into List. After this it will add the id value as key and extract the SubList from the parentList, adding the SubList as value based on the length from a different array.

/**
  * @param args
  * 
  */
 public static void main(String[] args){
  
  String[] array = {"23,29,1", "3,36,1", "13,43,1", "15,50,1", "23,57,1", "23,64,1", "23,71,1", "23,78,1", "23,85,1", "23,92,1", "23,99,1"};
  String[] arraySize = {"6", "5"};
  String[] idKey = {"29", "30"};
  
  //Initialising List holds the values for all sections
  List<String> averageList = new ArrayList<String>();
  //Initialising sectionMap idKey and averageList values as key and value pairs. 
  HashMap<String, List> sectionMap = new HashMap<String, List>();
  //Iterate the Array to split the elements using Comma
  for (String average: array){
   String[] details = average.split(",");
   averageList.add(details[0]); 
  } 
  
  int endIndex = 0;
  int beginIndex = 0;
  /* Iterate the arraySize to add idKey 
   * and averageList values as key and value pairs. 
   */ 
  for(int i=0; i<arraySize.length; i++){
   if (i==0){
    beginIndex = 0;
    //Assigning the endIndex from the arraySize
    endIndex = new Integer(arraySize[i]);
    //Adding the idKey and extracting the subList from the averageList into sectionMap
    sectionMap.put(idKey[i], averageList.subList(beginIndex, endIndex));
   }else {
    //Assigning endIndex as beginIndex for i>0
    beginIndex = endIndex;
    endIndex = endIndex + new Integer(arraySize[i]);
    sectionMap.put(idKey[i], averageList.subList(beginIndex, endIndex));
   }
  }
  System.out.println("sectionMap -->" +sectionMap);
 }

[ Read More ]

Dynamically resizing an Array using java

Dynamically resizing an Array using java

private static Object resizeArray (Object oldArray, int newSize) {
   int oldSize = java.lang.reflect.Array.getLength(oldArray);
   Class elementType = oldArray.getClass().getComponentType();
   Object newArray = java.lang.reflect.Array.newInstance(
         elementType,newSize);
   int preserveLength = Math.min(oldSize,newSize);
   if (preserveLength > 0)
      System.arraycopy (oldArray,0,newArray,0,preserveLength);
   return newArray;
}
 
// Test routine for resizeArray().
public static void main (String[] args) {
   int[] a = {1,2,3};
   a = (int[])resizeArray(a,5);
   a[3] = 4;
   a[4] = 5;
   for (int i=0; i<a.length; i++)
      System.out.println (a[i]);
}

[ Read More ]

Generic Array To String Function

public static String arrayToString(Object array) {    
 if (array == null) {
  return "[NULL]"; 
 }
 Object obj = null;   
 if (array instanceof Hashtable) {
  array = ((Hashtable)array).entrySet().toArray(); 
 }          else if (array instanceof HashSet) {
  array = ((HashSet)array).toArray(); 
 }      else if (array instanceof Collection) {
  array = ((Collection)array).toArray(); 
 }         

 int length = Array.getLength(array);  
 int lastItem = length - 1;  
 StringBuffer sb = new StringBuffer("[");  

 for (int i = 0; i < length; i++) {     

  obj = Array.get(array, i);      
  if (obj != null) { 

   sb.append(obj); 
  } else { 
   sb.append("[NULL]"); 
  }    
  if (i < lastItem) { 
   sb.append(", ");
  }    

 }    

 sb.append("]");    
 return sb.toString(); 
} 
}  

[ Read More ]

Program to Calculate the Length of Array

Here is a Java Program to demonstrates the length array member.

class Length {
  public static void main(String args[]) {
    int a1[] = new int[10];
    int a2[] = {3, 5, 7, 1, 8, 99, 44, -10};
    int a3[] = {4, 3, 2, 1};

    System.out.println("length of a1 is " + a1.length);
    System.out.println("length of a2 is " + a2.length);
    System.out.println("length of a3 is " + a3.length);
  }
}

Output of Above Java Program
length of a1 is 10
length of a2 is 8
length of a3 is 4

[ Read More ]

To Demonstrate a Three-Dimensional Array

Here is a Java Program to Demonstrate a three-dimensional array

class threeDMatrix {
  public static void main(String args[]) {
    int threeD[][][] = new int[3][4][5];
    int i, j, k;
    
    for(i=0; i<3; i++) 
      for(j=0; j<4; j++)
        for(k=0; k<5; k++)
        threeD[i][j][k] = i * j * k;

    for(i=0; i<3; i++) {
      for(j=0; j<4; j++) {
        for(k=0; k<5; k++) 
          System.out.print(threeD[i][j][k] + " "); 
        System.out.println();
      }
      System.out.println();
    }
  }
}

Output of Above Java Program
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12

0 0 0 0 0
0 2 4 6 8
0 4 8 12 16
0 6 12 18 24

[ Read More ]