Java知识实践—基础篇（二）

介绍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。

笔记