Java知识实践—基础篇(二)

笔记

Posted by Jingming on October 19, 2018

介绍Java常用类使用方法。

Long类

Long的最大值是2^63 - 1,接近小数点后18个0。

Long的乘法有个非常难察觉的错误:

例如:long l = 10000 * 10000000,那么结果l将不等于10^11。问题在于Java把10000和10000000作为int,所以进行了int的乘法, 溢出后转为int,然后赋值给long。

正确写法是:long l = (long)10000 * 10000000。

System类

System.getProperties()来获取所有可用的系统属性信息(包括执行文件的路径、操作系统类型等) 可以使用System.getProperty(String name)来获得特定的系统属性值。

String

String是不可修改的字符串(有时候会有intern操作),可修改的字符串要使用Stringbuilder(线程不安全)和Stringbuffer(线程安全)。

substring

String.length() 得到数组长度 substring(int beginIndex) 取出beginIndex到结尾的字符串 substring(int beginIndex,int endIndex) 取出beginIndex到endIndex,不包括endIndex指向的字符

修改String中的char

方法一: String s; char[] word = s.toCharArray(); //修改 String s2 = new String(word); 方法二: String str = “Test string”; StringBuilder strBuilder = new StringBuilder(str); strBuilder.setCharAt(1, ‘X’); str=Builder.toString();

string和char array转化

String s; char[] word = s.toCharArray(); String s2 = new String(word);

StringBuilder使用

public String reverseString(String s) { return new StringBuilder(s).reverse().toString(); }

sb.deleteCharAt(sb.length() - 1); // 删除最后一个字符

int转string

int i; Integer.toString(i) or String.valueOf(i)

char转String

char ch = ‘P; //char to string conversion String str = String.valueOf(ch);

str.charAt(0);

compareTo

s1.compareTo(s2):

if s1 > s2, it returns positive number if s1 < s2, it returns negative number
if s1 == s2, it returns 0

String[] 排序

先根据长度从长到短排序,如果相等,按字母顺序排序

Arrays.sort(strs, (s1, s2) -> { if (s1.length() == s2.length()) { return s1.compareTo(s2); } else { return s2.length() - s1.length(); // 不能为s2.length() < s1.length(),因为类型要和其他return值相同。 } });

List

在末尾添加元素:list.add(e); 取出元素:list.get(i); 更新元素:list.set(i, “New”); list大小:list.size();

LinkedList

相比于List的特殊操作 取出最后元素:s.getLast(); 弹出最后元素:s.pollLast();

List排序

list.sort((a, b) -> { xxx })

其中的xxx是一个表达式,返回结果三种情况,大于0,等于0,小于0;意思是将数组的元素(a,b)两两比较的时候, 如果大于0,那么就交换成(b, a),也就是把b排在a的前面,否则不交换。

xxx 例如 a[0] - b[0],这样a,b数组将按照第一个字段升序排序。

List初始化

List strings = new ArrayList(Arrays.asList("foo", "bar", "baz"))

List转array

List<Integer> list = new ArrayList<>(); 
int[] res = new int[list.size()]; 
for (int i = 0; i < list.size(); ++i) res[i] = list.get(i);

注意:如果题目直接需要array且知道array大小n,那么一开始直接申请array比较好,像这样: int[] arr = new int[n];

List 转Queue

String data; Queue q = new LinkedList<>(Arrays.asList(data.split(" ")));

Queue

        Queue<String> queue = new LinkedList<String>();
        int removedele = q.remove();
        System.out.println("removed element-"
                           + removedele);

        System.out.println(q); 
  
        // To view the head of queue 
        int head = q.peek(); 
        System.out.println("head of queue-"
                           + head); 
  
        // Rest all methods of collection 
        // interface like size and contains 
        // can be used with this 
        // implementation. 
        int size = q.size(); 
        System.out.println("Size of queue-"
                           + size); 

插入一个元素: q.offer(); 查看第一个元素:q.peek(); 弹出(删除)第一个元素:q.poll();

PriorityQueue

小堆顶PriorityQueue:PriorityQueue pq= new PriorityQueue(); 大堆顶PriorityQueue: PriorityQueue queue = new PriorityQueue<>(10, Collections.reverseOrder()); // 10是初始化数量,没有关系的 或者PriorityQueue pq =new PriorityQueue<>((x, y) -> Integer.compare(y, x));

PriorityQueue<Map.Entry<Integer, Integer» pq = new PriorityQueue<>((o1, o2) -> o1.getValue() - o2.getValue()); Queue pq = new PriorityQueue<>((a, b) -> b - a);

Stack

empty() peek() pop() push()

Map

(1)map.put(word, map.getOrDefault(word, 0) + 1);

(2)if (map.containsKey(word)) map.put(word, map.get(word) + 1); else map.put(word, 1);

(3)for (String key : map.keySet()) {} for (Object value : map.values()) {} for (Map.Entry<String, Object> entry : map.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); }

for (Map.Entry<Integer, Integer> entry : map.entrySet()) { System.out.println(“Key = “ + entry.getKey() + “, Value = “ + entry.getValue()); }

(4) graph,computeIfAbsent(key, k -> new Prioirty().add(val)) computeIfAbsent的意思是如果key没有对应的value,那么compute一个,所谓的compute就是使用lamda的map方法计算一个。

Array

int[] arr = {13, 7, 6, 45, 21, 9, 101, 102}; Arrays.sort(arr, (a, b) -> a - b); // a - b 作为lambda结果,如果大于0,那么是true,也就是要交换,因此是升序。 System.out.printf(“Modified arr[] : %s”, Arrays.toString(arr)); System.out.println(byteKey + “ found at index = “ +Arrays.binarySearch(arr, 6));

转List: Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; List targetList = Arrays.asList(sourceArray); **注意**,必须是Integer, int不行。

二维array排序: Arrays.sort(matrix, (a, b) -> a[0] != b[0] ? a[0] - b[0] : b[1] - a[1]);// 不能使用 a[0] < b[0]这种作为返回,因为类型不是int

Set

Set set = new HashSet<>();

for(String value: set){ System.out.println(value); }

判断一个元素是否存在: set.contains(元素)。

TreeSet

注意:不能存放相同元素

Comparator comparator = (a, b) -> nums\[a] != nums\[b] ? Integer.compare(nums\[a], nums\[b]) : a - b; TreeSet left = new TreeSet<>(comparator.reversed()); TreeSet right = new TreeSet<>(comparator); left.first(); left.pollFirst(); 检查元素存在:contains() 删除元素:remove()

floorKey(target_key): It returns the greatest key less than or equal to the given key。也就是说,找到 <= target的第一个数。如果不存在,那么 返回nil。

floorEntry(target_key):和floorKey()一样,比较的是key,不过返回的是entry。

ceilingEntry(target_key): 返回是的 >= target的第一个数,等价于c++的lowerbound。