Java 基本数据类型和数据结构

    
import java.lang.*;
import java.util.*;

public class JavaLanguageDataStructure {

    public static void main(String[] args) {
        System.out.println("Hello World!");
        System.out.println("This is the basic java data structure");
        System.out.println("/****************************************/");

        //basic data types
        //primitive data types
        byte    myByte          = 0101;
        short   myShort         = 101;
        int     myNumInteger    = 5;
        long    myLong          = 100000000;
        float   myNumFloat      = 5.99f;
        double  myNumDouble     = 5.99;
        char    myChar          = 'D';
        boolean myBool          = true;

        System.out.println("myByte: " + myByte);
        System.out.println("myShort: " + myShort);
        System.out.println("myNumInteger: " + myNumInteger);
        System.out.println("myLong: " + myLong);
        System.out.println("myNumFloat: " + myNumFloat);
        System.out.println("myNumDouble: " + myNumDouble);
        System.out.println("myChar: " + myChar);
        System.out.println("myBool: " + myBool);

        //Non-Primitive datatype
        System.out.println("/****************************************/");
        System.out.println("/*************String*****************/");
        String  s        =  "Hello";
        //Array
        //Class
        System.out.println("myString: " + s);
        s.charAt(0);
        s.length();
        s.substring(0, 1);
        s.substring(1);
        s.subSequence(1, 3);
        s.equals("abc");
        s.equalsIgnoreCase("abc");
        s = s.trim();
        s.indexOf("e");
        s.indexOf("e", 2);
        s.lastIndexOf("e");
        s.toCharArray();
        Integer.valueOf("5"); //returns an Integer object
        Integer.parseInt("5"); //returns an int primitive
        String.valueOf(5);   //integer to string

        //String builder
        StringBuilder sb = new StringBuilder();
        sb.append("a");
        sb.insert(0, "b");
        sb.append("c");
        sb.deleteCharAt(sb.length() - 1);
        sb.reverse();
        sb.toString();

        //Array
        int[] a = new int [10];
        char[] b = {'a', 'b'};
        int [][] c = new int[5][10];
        int rows = c.length;
        int cols = c[0].length;
        int max = Integer.MAX_VALUE;
        int min = Integer.MIN_VALUE;
        Arrays.sort(a);
        for(int i = 0; i < c.length; i++){
            System.out.println(c[i]);
        }

        //List
        List<Integer> list = new ArrayList<Integer>();
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<List<Integer>> list2 = new ArrayList<List<Integer>>();
        list.add(0);
        list.add(0, 1);
        list.add(3);
        list.get(0);
        list.size();
        list.remove(list.size() - 1);
        Collections.sort(list);
        Collections.sort(list, Collections.reverseOrder());
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        //Stack
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(0);
        stack.push(1);
        stack.peek();
        stack.pop();
        stack.isEmpty();
        stack.size();

        //Queue
        Queue<Integer> q = new LinkedList<Integer>();
        ((LinkedList<Integer>) q).add(0);
        q.add(1);
        q.remove();
        q.peek();
        q.isEmpty();
        q.size();

        //HashMap
        HashMap<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "abc");
        map.get(1);
        map.put(2, "bcd");
        if(map.containsKey(1))
        {}
        if(map.containsValue("abc")){
        }
        for(Integer k : map.keySet()){}
        for(String v :map.values()){
        }
        map.isEmpty();
        map.size();

        //HashSet
        HashSet<Integer> set = new HashSet<Integer>();
        set.add(0);
        set.add(1);
        set.remove(0);
        if(set.contains(0)){}
        set.isEmpty();
        set.size();

        //min heap
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
        pq.add(0);
        pq.remove(0);
        pq.add(1);
        pq.peek();
        pq.isEmpty();
        pq.size();
        while(!pq.isEmpty()){}
    }
}