java小知识

迈不过友情╰ 2021-09-18 11:24 294阅读 0赞

[位运算技巧][Link 1]  
[java各常用集合类是否接受null值][java_null]  
[float long double][]

Java基本类型占用的字节数：
    1字节： byte , boolean
    2字节： short , char
    4字节： int , float
    8字节： long , double
    注：
    1字节(byte)=8位(bits)
    char在Java中占用2字节。Java编译器默认使用Unicode编码，因此2字节可以表示所有字符。

new Integer(123) 与 Integer.valueOf(123) 的区别在于：
    new Integer(123) 每次都会新建一个对象；
    Integer.valueOf(123) 会使用缓存池中的对象，多次调用会取得同一个对象的引用。

对于基本类型，== 判断两个值是否相等，基本类型没有 equals() 方法。
    对于引用类型，== 判断两个变量是否引用同一个对象，而 equals() 判断引用的对象是否等价。

final：
    对于基本类型，final 使数值不变；
    对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。
    声明方法不能被子类重写。
    声明类不允许被继承。

long lNum  = 1234L;
    float fNum = 1.23f;
    double dNum = 1.23d;

//队列声明
    Queue<String> queue = new LinkedList<String>();

//嵌套列表
    List<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
    List<List<Integer>> list = new ArrayList<List<Integer>>();
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
    
    List<List<Integer>> children = new ArrayList<>(N);
    for(int i = 0; i < N; i++) {
        children.add(new LinkedList<>());
    }

//重载了操作+
    123 + "" 
    "123"

//优先队列重定义排序,默认小顶堆
        private PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

// 二维数组排序
    Arrays.sort(arr,new Comparator<String []>() {
    	@Override
    	public int compare(String[] aa, String[] bb) {
    		if(aa[0].compareTo(bb[0])==0){
    			return aa[1].compareTo(bb[1]);
    		}
    			return aa[0].compareTo(bb[0]);
    	}
    });

集合数组的声明方式
     Queue<TreeNode>[] que = new Queue[2];
     que[0] = new LinkedList<TreeNode>();
     que[1] = new LinkedList<TreeNode>();

asList接受的是一个泛型类型的参数，再构造了一个ArrayList。然而基本类型是不支持泛型化的，但是数组支持。
    
    asList返回的ArrayList并不是我们熟悉的java.util.ArrayList，而是另一个类
    Integer[] datas = new Integer[]{1,2,3,4,5};
    ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(datas));

lambda排序：
    Arrays.sort(intervals, (a,b) -> a[0]!=b[0]?a[0]-b[0]:b[1]-a[1] );

ArrayList转int[]
    ArrayList<int[]> out = new ArrayList<>();
    out.toArray(new int[out.size()][2]);

数组clone
    int[] snums = nums.clone();

scanner类：
    nextInt() / next() 在一开始遇到换行和空白时会跳过，然后遇到数字字符进行解析，最后遇到空白或换行终止读取，并且会把空白或换行留在缓冲区。
    nextLine()  在读取到空白会读进字符串，然后遇到字符会读入，遇到换行终止读入，并且把换行符处理掉。
    
    
    import java.util.*;
    class Main{
        public static void main(String[] args){
            Scanner in = new Scanner(System.in);
            int x = in.nextInt();
            System.out.println(x);
            int y = in.nextInt();
            System.out.println(y);
            in.next();
            String line = in.nextLine();
            System.out.println(line);
            line = in.nextLine();
            System.out.println(line);
        }
    }
    输入：
    1 2
     3 4
    5 6
    输出：
    1
    2
     4
    5 6

[Link 1]: https://cyc2018.github.io/CS-Notes/#/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E4%BD%8D%E8%BF%90%E7%AE%97
[java_null]: https://blog.csdn.net/ml1990s/article/details/11649237
[float long double]: https://blog.csdn.net/fx677588/article/details/52663805