Programación.Click

import java.util.Scanner;
public class Looking {
    public static void main(String[] args){
        String input = "1 2 a 3 45 6";
        Scanner sc = new Scanner(input);
        int x = 0;
        do{
            x = sc.nextInt();
            System.out.print(x + " ");
        }while(x != 0);
    }
}

run:
Exception in thread "main" java.util.InputMismatchException
        at java.util.Scanner.throwFor(Scanner.java:840)
        at java.util.Scanner.next(Scanner.java:1461)
        at java.util.Scanner.nextInt(Scanner.java:2091)
        at java.util.Scanner.nextInt(Scanner.java:2050)
        at Looking.main(Looking.java:19)
1 2 Java Result: 1
BUILD SUCCESSFUL (total time: 0 seconds)

public class Looking {
    public static void main(String[] args){
        String input = "1 2 a 3 45 6";
        Scanner sc = new Scanner(input);
        int x = 0;
        while(sc.hasNextInt()){
            x = sc.nextInt();
            System.out.print(x + " ");
        }
    }
}

run:
1 2 BUILD SUCCESSFUL (total time: 0 seconds)

import java.util.Arrays;
import java.util.Comparator;
 
public class SearchObjArray {
    public static void main(String[] args){
        String [] sa = {"one", "two", "three", "four"};
        Arrays.sort(sa);
        for(String s : sa){
            System.out.print(s + " ");
        }
        System.out.println("none = " + Arrays.binarySearch(sa, "one"));
 
        System.out.println("now reverse sort");
        ReSortComparator rs = new ReSortComparator();
        Arrays.sort(sa, rs);//re-sort the array using the Comparator. sort(sa, rs)
        for(String s : sa){
            System.out.print(s + " ");
        }
        System.out.println("none = " + Arrays.binarySearch(sa, "one"));//doesn't pass the binarySearch() method the Comparator we used to sort the array, so get an incorrect answer
        System.out.println("one = " + Arrays.binarySearch(sa,"one", rs));//passing the Comparator to binarySearch(), so get correct answer
    }
    static class ReSortComparator implements Comparator{//define the Comparator, it's ok for this to be an inner class
        public int compare(String a, String b){
            return b.compareTo(a);
        }
    }
}

import java.util.Comparator;
import java.util.PriorityQueue;
 
public class PriorityQueueTest {
 
	static class PQsort implements Comparator<Integer> {
 
		public int compare(Integer one, Integer two) {
			return two - one;
		}
	}
 
	public static void main(String[] args) {
		int[] ia = { 1, 10, 5, 3, 4, 7, 6, 9, 8 };
		PriorityQueue<Integer> pq1 = new PriorityQueue<Integer>();
 
		// use offer() method to add elements to the PriorityQueue pq1
		for (int x : ia) {
			pq1.offer(x);
		}
 
		System.out.println("pq1: " + pq1);
 
		PQsort pqs = new PQsort();
		PriorityQueue<Integer> pq2 = new PriorityQueue<Integer>(10, pqs);
		// In this particular case, we can simply use Collections.reverseOrder()
		// instead of self-defined comparator
		for (int x : ia) {
			pq2.offer(x);
		}
 
		System.out.println("pq2: " + pq2);
 
		// print size
		System.out.println("size: " + pq2.size());
		// return highest priority element in the queue without removing it
		System.out.println("peek: " + pq2.peek());
		// print size
		System.out.println("size: " + pq2.size());
		// return highest priority element and removes it from the queue
		System.out.println("poll: " + pq2.poll());
		// print size
		System.out.println("size: " + pq2.size());
 
		System.out.print("pq2: " + pq2);
 
	}
}

import java.util.Iterator;
import java.util.TreeSet;
 
public class TreeSetExample {
 
   public static void main(String[] args) {
	System.out.println("Tree Set Example!n");
	TreeSet<Integer> tree = new TreeSet<Integer>();
	tree.add(12);
	tree.add(63);
	tree.add(34);
	tree.add(45);
 
	// here it test it's sorted, 63 is the last element. see output below
	Iterator<Integer> iterator = tree.iterator();
	System.out.print("Tree set data: ");
 
	// Displaying the Tree set data
	while (iterator.hasNext()) {
		System.out.print(iterator.next() + " ");
	}
	System.out.println();
 
	// Check empty or not
	if (tree.isEmpty()) {
		System.out.print("Tree Set is empty.");
	} else {
		System.out.println("Tree Set size: " + tree.size());
	}
 
	// Retrieve first data from tree set
	System.out.println("First data: " + tree.first());
 
	// Retrieve last data from tree set
	System.out.println("Last data: " + tree.last());
 
	if (tree.remove(45)) { // remove element by value
		System.out.println("Data is removed from tree set");
	} else {
		System.out.println("Data doesn't exist!");
	}
	System.out.print("Now the tree set contain: ");
	iterator = tree.iterator();
 
	// Displaying the Tree set data
	while (iterator.hasNext()) {
		System.out.print(iterator.next() + " ");
	}
	System.out.println();
	System.out.println("Now the size of tree set: " + tree.size());
 
	// Remove all
	tree.clear();
	if (tree.isEmpty()) {
		System.out.print("Tree Set is empty.");
	} else {
		System.out.println("Tree Set size: " + tree.size());
	}
   }
}

import java.util.TreeSet;
 
class Dog {
    int size;
    Dog(int s) {
        size = s;
    }
}
 
public class ImpComparableWrong {
 
    public static void main(String[] args) {
        TreeSet<Integer> i = new TreeSet<Integer>();
        TreeSet<Dog> d = new TreeSet<Dog>();
        d.add(new Dog(1));
        d.add(new Dog(2));
        d.add(new Dog(1));
 
        i.add(1);
        i.add(2);
        i.add(3);
 
        System.out.println(d.size() + &quot; &quot; + i.size());
    }
}

import java.util.TreeSet;
 
class Dog implements Comparable<Dog> {
 
    int size;
 
    Dog(int s) {
        size = s;
    }
 
    public int compareTo(Dog o) {
        return size - o.size;
    }
}
 
public class ImpComparable {
 
    public static void main(String[] args) {
 
        TreeSet<Dog> d = new TreeSet<Dog>();
        d.add(new Dog(1));
        d.add(new Dog(2));
        d.add(new Dog(1));
 
        TreeSet<Integer> i = new TreeSet<Integer>();
        i.add(1);
        i.add(2);
        i.add(3);
 
        System.out.println(d.size() + &quot; &quot; + i.size());
    }
}