public class Util {
public static void printBag(Bag<?> bag ) {
System.out.println(bag.toString());
}
}
Bag<String> myBag1 = new Bag("Hello");
Bag<Integer> myBag2 = new Bag(23);
Util.printBag(myBag1); // Hello
Util.printBag(myBag2); // 23
public static <T> void printBag(Bag<T> bag ) {
System.out.println(bag.toString());
}
public static <T> Bag<T> getBag(Bag<T> bag ) {
return bag;
}
public static void printBag(Bag<? extends Number> bag ) {
System.out.println(bag.toString());
}
//Wildcard Lower Bounds
//A lower bound wildcard restricts the wildcard to a class or interface and any of its parent types.
//There are some general guidelines provided by Java as to when to use what type of wildcard:
//An upper bound wildcard should be used when the variable is being used to serve some type of data to our code.
//A lower bound wildcard should be used when the variable is receiving data and holding it to be used later.
//When a variable that serves data is used and only uses Object methods, an unbounded wildcard is preferred.
//When a variable needs to serve data and store data for use later on, a wildcard should not be used (use a type parameter instead).
//An upper bound restricts the type parameter to a class or any of its sub-classes and is done this way: SomeClass<? extends SomeType>. A lower bound restricts the type parameter to a class or any of its parent classes and is done this way: SomeClass<? super SomeType>.
public class Util {
public static void getBag(Bag<? super Integer> bag ) {
return bag;
}
}
import javax.swing.*;
public class FirstSwingExample {
public static void main(String[] args) {
JFrame f=new JFrame();//creating instance of JFrame
JButton b=new JButton("click");//creating instance of JButton
b.setBounds(130,100,100, 40);//x axis, y axis, width, height
f.add(b);//adding button in JFrame
f.setSize(400,500);//400 width and 500 height
f.setLayout(null);//using no layout managers
f.setVisible(true);//making the frame visible
}
}
List<String> songList = new ArrayList<>();
songList.add("Some song"); //Repeat until satisfied
System.out.println("\n\tWelcome! Please choose a song!");
String songChoice = scan.nextLine();
while (!songList.contains(songChoice)) {
//Do stuff when input is not a recognised song
}
import java.util.Stack;
/**
* Java Program to implement a binary search tree. A binary search tree is a
* sorted binary tree, where value of a node is greater than or equal to its
* left the child and less than or equal to its right child.
*
* @author WINDOWS 8
*
*/
public class BST {
private static class Node {
private int data;
private Node left, right;
public Node(int value) {
data = value;
left = right = null;
}
}
private Node root;
public BST() {
root = null;
}
public Node getRoot() {
return root;
}
/**
* Java function to check if binary tree is empty or not
* Time Complexity of this solution is constant O(1) for
* best, average and worst case.
*
* @return true if binary search tree is empty
*/
public boolean isEmpty() {
return null == root;
}
/**
* Java function to return number of nodes in this binary search tree.
* Time complexity of this method is O(n)
* @return size of this binary search tree
*/
public int size() {
Node current = root;
int size = 0;
Stack<Node> stack = new Stack<Node>();
while (!stack.isEmpty() || current != null) {
if (current != null) {
stack.push(current);
current = current.left;
} else {
size++;
current = stack.pop();
current = current.right;
}
}
return size;
}
/**
* Java function to clear the binary search tree.
* Time complexity of this method is O(1)
*/
public void clear() {
root = null;
}
}
import java.io.*;
import java.util.*;
class GFG
{
static int maxCuts(int n, int a, int b, int c)
{
if(n == 0) return 0;
if(n < 0) return -1;
int res = Math.max(maxCuts(n-a, a, b, c),
Math.max(maxCuts(n-b, a, b, c),
maxCuts(n-c, a, b, c)));
if(res == -1)
return -1;
return res + 1;
}
public static void main(String [] args)
{
int n = 5, a = 2, b = 1, c = 5;
System.out.println(maxCuts(n, a, b, c));
}
}
class Solution{
//Function to count the frequency of all elements from 1 to N in the array.
public static void frequencyCount(int arr[], int N, int P)
{
//Decreasing all elements by 1 so that the elements
//become in range from 0 to n-1.
int maxi = Math.max(P,N);
int count[] = new int[maxi+1];
Arrays.fill(count, 0);
for(int i=0;i<N;i++){
count[arr[i]]++;
}
for(int i=0;i<N;i++){
arr[i] = count[i+1];
}
}
}
// IntendedActivity - the file you wish to open
// CurrentActivity - the file where this code is placed
Intent intent = new Intent (this, IntendedActivity.class);
CurrentActivity.this.startActivity(intent);
public class LocalDatabase extends SQLiteOpenHelper {
private static final String mDatabaseName = "LocalDatabase";
private static final int mDatabaseVersion = 1;
public LocalDatabase(Context context) {
super(context, mDatabaseName, null, mDatabaseVersion);
SQLiteDatabase db = this.getWritableDatabase();
}
}
Comments