# Aug 9, 2018

## Python

### `collections.Counter()`

Documentation: [https://docs.python.org/2/library/collections.html#collections.Counter](https://docs.python.org/2/library/collections.html#collections.Counter)

A counter is a container that _stores elements as dictionary keys_, and _their counts are stored as dictionary values_.

**Sample code**:

```python
>>> from collections import Counter
>>> 
>>> myList = [1,1,2,3,4,5,3,2,3,4,2,1,2,3]
>>> print Counter(myList)
Counter({2: 4, 3: 4, 1: 3, 4: 2, 5: 1})
>>>
>>> print Counter(myList).items()
[(1, 3), (2, 4), (3, 4), (4, 2), (5, 1)]
>>> 
>>> print Counter(myList).keys()
[1, 2, 3, 4, 5]
>>> 
>>> print Counter(myList).values()
[3, 4, 4, 2, 1]
```

**Related practice**:

[https://www.hackerrank.com/challenges/collections-counter/problem](https://www.hackerrank.com/challenges/collections-counter/problem)

## Java

### `ArrayList<>()` vs `LinkedList<>()`

1. [ArrayList](https://www.geeksforgeeks.org/arraylist-in-java/): Implemented with the concept of **dynamic array**.

```java
ArrayList<Type> arrL = new ArrayList<Type>();

Here Type is the data type of elements in ArrayList
to be created
```

1. [LinkedList](http://geeksquiz.com/linked-list-in-java/): Implemented with the concept of **doubly linked list**.

```java
LinkedList<Type> linkL = new LinkedList<Type>();

Here Type is the data type of elements in LinkedList
to be created
```

ArrayList and LinkedList both **implements List interface** and **maintains insertion order**. Both are **non synchronized classes**.

But there are many differences between ArrayList and LinkedList classes that are given below.

| **ArrayList**                                                                                                                                          | **LinkedList**                                                                                                                        |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
| ArrayList internally uses **dynamic array** to store the elements.                                                                                     | LinkedList internally uses **doubly linked list** to store the elements.                                                              |
| Manipulation with ArrayList is **slow** because it internally uses array. If any element is removed from the array, all the bits are shifted in memory | Manipulation with LinkedList is **faster** than ArrayList because it uses Doubly Linked List so no bit shifting is required in memory |
| ArrayList class can **act as a list** only because it implements List only                                                                             | LinkedList class can **act as a list and queue** both because it implements List and Deque interfaces                                 |
| ArrayList is **better for storing and accessing data**                                                                                                 | LinkedList is **better for manipulating data**                                                                                        |

Comparison between [ArrayList](https://www.geeksforgeeks.org/arraylist-in-java/) and [LinkedList](http://geeksquiz.com/linked-list-in-java/):

1. Insertions are easy and fast in LinkedList as compared to ArrayList because there is no risk of **resizing array and copying content to new array** if array gets full which makes adding into **ArrayList of O(n) in worst case, while adding is O(1) operation in LinkedList** in Java. ArrayList also needs to be update its index if you insert something anywhere except at the end of array.
2. Removal also better in **LinkedList** than **ArrayList** due to same reasons as insertion.
3. **LinkedList has more memory overhead than ArrayList** because in **ArrayList each index only holds actual object (data)** but in case of **LinkedList each node holds both data and address of next and previous node**.
4. **Both LinkedList and ArrayList require O(n) time to find** if an element is present or not. **However we can do Binary Search on ArrayList if it is sorted and therefore can search in O(Log n) time**.

### remove an element from ArrayList

1. using remove() method
2. using Iterator.remove() method

#### using remove() method

**ArrayList** provides two overloaded `remove()` method.

1. `remove(int index)` : Accept index of object to be removed.
2. `remove(Obejct obj)` : Accept object to be removed.

```java
// Java program to demonstrate working of remove
// on an integer arraylist
import java.util.List;
import java.util.ArrayList;

public class GFG
{
    public static void main(String[] args)
    {
        List al = new ArrayList();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(1);
        al.add(2);

        // This makes a call to remove(int) and 
        // removes element 20.
        al.remove(1);

        // Now element 30 is moved one position back
        // So element 30 is removed this time
        al.remove(1);

        System.out.println("Modified ArrayList : " + al);
    }
}
```

Output :

```
Modified ArrayList : [10, 1, 2]
```

We can see that the passed parameter is considered as index. How to remove elements by value.

```java
// Java program to demonstrate working of remove
// on an integer arraylist
import java.util.List;
import java.util.ArrayList;

public class GFG
{
    public static void main(String[] args)
    {
        List al = new ArrayList();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(1);
        al.add(2);

        // This makes a call to remove(Object) and 
        // removes element 1
        al.remove(new Integer(1));

        // This makes a call to remove(Object) and 
        // removes element 2
        al.remove(new Integer(2));

        System.out.println("Modified ArrayList : " + al);
    }
}
```

Output :

```
Modified ArrayList : [10, 20, 30]
```

### Check whether a string is not null and not empty

`String.isEmpty()`:

```java
public boolean isEmpty()
Returns true if, and only if, length() is 0.
Returns:
true if length() is 0, otherwise false
```

Be sure to use the parts of`&&`in this order, because java will not proceed to evaluate the second part if the first part of`&&`fails, thus ensuring you will not get a null pointer exception from`str.isEmpty()`if`str`is null.

_Beware, it's only available since Java SE 1.6_. You have to check`str.length() == 0`on previous versions.

```java
if(str != null && !str.isEmpty())
```

To ignore whitespace as well:

```java
if(str != null && !str.trim().isEmpty())
```

**Aside**:

`String.trim()`:

```java
public String trim()

Returns a copy of the string, with leading and trailing whitespace omitted.

    If this String object represents an empty character sequence, or the first and last characters of character
    sequence represented by this String object both have codes greater than '\u0020' (the space character), then
    a reference to this String object is returned.

    Otherwise, if there is no character with a code greater than '\u0020' in the string, then a new String object
    representing an empty string is created and returned.

    Otherwise, let k be the index of the first character in the string whose code is greater than '\u0020', and
    let m be the index of the last character in the string whose code is greater than '\u0020'. A new String object
    is created, representing the substring of this string that begins with the character at index k and ends with
    the character at index m-that is, the result of this.substring(k, m+1).

    This method may be used to trim whitespace (as defined above) from the beginning and end of a string.

Returns:
        A copy of this string with leading and trailing white space removed, or this string if it has no leading
        or trailing white space.
```

### `String.toCharArray()`

The java `String.toCharArray()` method **converts the given string into a sequence of characters**. The **returned array length is equal to the length of the string**.

**Syntax:**

```
public char[] toCharArray()   
Return : It returns a newly allocated character array.
```

**Example**:

```java
public class CharArrayExample{
   public static void main(String args[]){
       String str = new String("Welcome to BeginnersBook.com");
       char[] array= str.toCharArray();
       System.out.print("Content of Array:");
       for(char c: array){
           System.out.print(c);
       }
   }
}
```

**Output:**

```
Content of Array:Welcome to BeginnersBook.com
```

### String.valueOf()

This method has the following variants, which depend on the passed parameters. **This method returns the String representation of the passed argument**.

* `valueOf(boolean b)` − Returns the string representation of the boolean argument.
* `valueOf(char c)` − Returns the string representation of the char argument.
* `valueOf(char[] data)` − Returns the string representation of the char array argument.
* `valueOf(char[] data, int offset, int count)` − Returns the string representation of a **specific subarray of the char array** argument.
* `valueOf(double d)` − Returns the string representation of the double argument.
* `valueOf(float f)` − Returns the string representation of the float argument.
* `valueOf(int i)` − Returns the string representation of the int argument.
* `valueOf(long l)` − Returns the string representation of the long argument.
* `valueOf(Object obj)` − Returns the **string representation of the Object argument**.

**Example**:

```java
import java.io.*;
public class Test {

   public static void main(String args[]) {
      double d = 102939939.939;
      boolean b = true;
      long l = 1232874;
      char[] arr = {'a', 'b', 'c', 'd', 'e', 'f','g' };

      System.out.println("Return Value : " + String.valueOf(d) );
      System.out.println("Return Value : " + String.valueOf(b) );
      System.out.println("Return Value : " + String.valueOf(l) );
      System.out.println("Return Value : " + String.valueOf(arr) );
   }
}
```

**Output**:

```java
Return Value : 1.02939939939E8
Return Value : true
Return Value : 1232874
Return Value : abcdefg
```

### `String.valueOf()` vs. `Object.toString()`

According to the Java documentation, `String.valueOf()` returns:

> if the argument is null, then a string equal to `"null"`; otherwise, the value of `obj.toString()` is returned.

So there shouldn't really be a difference except for an additional method invocation.

Also, in the case of `Object.toString()`, if the instance is null, a `NullPointerException` will be thrown, so arguably, it's less safe.

```java
public static void main(String args[]) {  
    String str = null;
    System.out.println(String.valueOf(str));  // This will print a String equal to "null"        
    System.out.println(str.toString());       // This will throw a NullPointerException
}
```

### `Map.entrySet()`

The `entrySet()` method is used to **get a Set view of the mappings contained in this map**. The method call returns a set view of the mappings contained in this map.

**Example**:

```java
import java.util.*;

public class HashMapDemo {
   public static void main(String args[]) {

      // create hash map
      HashMap newmap = new HashMap();

      // populate hash map
      newmap.put(1, "tutorials");
      newmap.put(2, "point");
      newmap.put(3, "is best");

      // create set view for the map
      Set set = newmap.entrySet();

      // check set values
      System.out.println("Set values: " + set);
   }    
}
```

**Output**:

```
Set values: [1=tutorials, 2=point, 3=is best]
```

`Map.Entry`is a **key and its value combined into one class**. This allows you to iterate over`Map.entrySet()`instead of having to iterate over`Map.keySet()`, then getting the value for each key. A better way to write what you have is:

```java
for (Map.Entry<String, JButton> entry : listbouton.entrySet()) {
    String key = entry.getKey();
    JButton value = entry.getValue();

    this.add(value);
}
```

### `ArrayList.addAll()`

`boolean addAll(Collection c)`:

This method **appends all of the elements in the specified collection to the end of this list**, in the order that they are returned by the specified collection’s Iterator. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress(implies that the behavior of this call is undefined if the specified collection is this list, and this list is nonempty).

```
Parameters:
c : This is the collection containing elements to be added to this list.
Exception:
NullPointerException : If the specified collection is null
```

**Example**:

```java
// Java program to illustrate
// boolean addAll(Collection c)
import java.io.*;
import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String args[])
    {

        // create an empty array list1 with initial 
        // capacity as 5
        ArrayList<Integer> arrlist1 = 
                           new ArrayList<Integer>(5);

        // use add() method to add elements in the list
        arrlist1.add(12);
        arrlist1.add(20);
        arrlist1.add(45);

        // prints all the elements available in list1
        System.out.println("Printing list1:");
        for (Integer number : arrlist1) 
            System.out.println("Number = " + number);        

        // create an empty array list2 with an initial
        // capacity
        ArrayList<Integer> arrlist2 = 
                             new ArrayList<Integer>(5);

        // use add() method to add elements in list2
        arrlist2.add(25);
        arrlist2.add(30);
        arrlist2.add(31);
        arrlist2.add(35);

        // let us print all the elements available in 
        // list2
        System.out.println("Printing list2:");
        for (Integer number : arrlist2) 
            System.out.println("Number = " + number);        

        // inserting all elements, list2 will get printed
        // after list1
        arrlist1.addAll(arrlist2);

        System.out.println("Printing all the elements");
        // let us print all the elements available in 
        // list1
        for (Integer number : arrlist1) 
            System.out.println("Number = " + number);        
    }
}
```

Output:

```
Output:Printing list1:
Number = 12
Number = 20
Number = 45
Printing list2:
Number = 25
Number = 30
Number = 31
Number = 35
Printing all the elements
Number = 12
Number = 20
Number = 45
Number = 25
Number = 30
Number = 31
Number = 35
```

`boolean addAll(int index, Collection c)`**:**

This method inserts all of the elements in the specified collection into this list, starting at the specified position. It shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the list in the order that they are returned by the specified collection’s iterator.

```
Parameters:
index : The index at which to insert the first element from the specified collection.
c : This is the collection containing elements to be added to this list.
Exception:
IndexOutOfBoundsException : If the index is out of range
NullPointerException : If the specified collection is null
```

Example:

```java
// Java program to illustrate
// boolean addAll(int index, Collection c)
import java.io.*;
import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String args[])
    {

        // create an empty array list1 with initial
        // capacity 5
        ArrayList<Integer> arrlist = 
                        new ArrayList<Integer>(5);

        // using add() method to add elements in the 
        // list
        arrlist.add(12);
        arrlist.add(20);
        arrlist.add(45);

        // prints all the elements available in list1
        System.out.println("Printing list1:");
        for (Integer number : arrlist) 
            System.out.println("Number = " + number);        

        // create an empty array list2 with an initial
        // capacity
        ArrayList<Integer> arrlist2 = 
                            new ArrayList<Integer>(5);

        // use add() method to add elements in list2
        arrlist2.add(25);
        arrlist2.add(30);
        arrlist2.add(31);
        arrlist2.add(35);

        // prints all the elements available in list2
        System.out.println("Printing list2:");
        for (Integer number : arrlist2) 
            System.out.println("Number = " + number);        

        // inserting all elements of list2 at third 
        // position
        arrlist.addAll(2, arrlist2);

        System.out.println("Printing all the elements");

        // prints all the elements available in list1
        for (Integer number : arrlist) 
            System.out.println("Number = " + number);        
    }
}
```

Output:

```
Output:Printing list1:
Number = 12
Number = 20
Number = 45
Printing list2:
Number = 25
Number = 30
Number = 31
Number = 35
Printing all the elements
Number = 12
Number = 20
Number = 25
Number = 30
Number = 31
Number = 35
Number = 45
```

## References

* GeeksforGeeks
* Stack Overflow
* tutorialspoint
