Java小tips记录

Java代码小知识点总结

List转Array

// 方法一：List.toArray(new Object[0])。注意，这种方法只对Object类型有效，换言之，int，char等无法使用。
String[] arr = list.toArray(new String[0]);

// 方法二：Stream。这种方式可以将Integer的list转为array
int[] array = list.stream().mapToInt(i->i).toArray();

// 方法三：新建array，一个个赋值，最稳健。
Integer[] arr = new Integer[list.size()];
for (int i = 0; i < list.size(); i++)) {
    arr[i] = list.get(i);
}

Array转List

// 方法一：Arrays.asList(arr)。注意：这种方式所返回的List不是我们常用的List，因此最好做一层转换。注意，这种方法只对Object类型有效，换言之，int，char等无法使用!!!

// 如果是int数组转Integer List，建议还是一个个加吧
List<Integer> list = new ArrayList<Integer>(Arrays.asList(arr));

// 方法二：Collections.addAll(list, arr)
List<Integer> list = new ArrayList<>();
Collections.addAll(list, arr);

// 方法三：Stream
List<Integer> list = Arrays.stream(arr).collect(Collectors.toList());

Collections.sort和Arrays.sort

参考：原文链接

Collections.sort()

其实主要是两种排序：Collections.sort(List,Comparator) 和 **List.sort(Comparator)**，其中Comparator可以用lamada表达式代替。

Attention:

1. Comparator不能更改基本类型的比较方式，只能更改复合类型或者数组类型。数组类型的比较我们可以参考：LeetCode 973. K Closest Points to Origin
2. 比较的时候，如果是stream的方式，不仅可以用两个object的属性比较，还可以使用额外的外面的变量，详情见:Post not found: LeetCode-1471-The-k-Strongest-Values-in-an-Array LeetCode 1471. The k Strongest Values in an Array

import com.google.common.collect.Lists;
import org.junit.Assert;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ComparatorTest {

    @Test
    public void test1(){
        /**
         * Collections.sort()使用
         */
        //被排序的集合
        List<User> userList = Lists.newArrayList(new User("Jack",11),new User("Jack",10));

        //1. Java8之前，使用匿名内部类的基本排序
        Collections.sort(userList, new Comparator<User>() {
            @Override
            public int compare(User user1, User user2) {
                return user1.getAge().compareTo(user2.getAge());
            }
        });

        //2. Java8,使用Lambda表达式的基本排序
        Collections.sort(userList,
                 (User user1, User user2) ->user1.getAge().compareTo(user2.getAge()));

        //userList.sort((User user1, User user2) -> user1.getAge().compareTo(user2.getAge()));

        //3. Java8,Lambda表达式可以简化，省略定义类型User
        userList.sort((user1, user2) -> user1.getAge().compareTo(user2.getAge()));

        //4. Java8,Lambda表达式，多条件排序
        userList.sort((user1, user2) -> {
            if (user1.getName().equals(user2.getName())) {
            return user1.getAge() - user2.getAge();
            } else {
            return user1.getName().compareTo(user2.getName());
            }
        });

        //5. Java8,多条件组合排序
        userList.sort(Comparator.comparing(User::getName).thenComparing(User::getAge));

        //6. Java8,提取Comparator进行排序
        Collections.sort(userList, Comparator.comparing(User::getName));

        //7. Java8,自定义静态的比较方法来排序(静态方法必须写在被比较的类(这里是User类)中)
        userList.sort(User::compareByAgeThenName);

        //8. Java8,反转排序
        Comparator<User> comparator = (user1, user2) -> user1.getName().compareTo(user2.getName());
        userList.sort(comparator);//先按name排序
        userList.sort(comparator.reversed());//反转排序
        Assert.assertEquals(userList.get(0),new User("Jack",10));
    }
}

Arrays.sort()

Arrays.sort(数组)默认是对数组进行升序排列，它有几种参数形式，这里以int数组为例：

1. **Arrays.sort(int[])**：直接从小到大进行排序
2. **Arrays.sort(int[], int from, int to)**：在[from,to)区间进行排序，左闭右开
3. **Arrays.sort(Integer[], Comparator)**：自定义Comparator排序顺序。

import com.google.common.collect.Lists;
import org.junit.Assert;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class ComparatorTest {

    @Test
    public void test1(){
        /**
         * Arrays.sort()使用
         */
        //被排序的字符串数组
        String[] months = {"January","February","March","April","May","June","July","August","September","October","December"};
        //按字符串长度排序
        //1.
        Arrays.sort(months, (a, b) -> Integer.signum(a.length() - b.length()));
        //2.
        Arrays.sort(months, Comparator.comparingInt(String::length));
        //3.
        Arrays.sort(months, (a, b) -> a.length() - b.length());
        //4.
        Arrays.sort(months,
                (String a, String b) -> { return Integer.signum(a.length() - b.length()); })
    }
}

构建List数组

Java不支持泛型数组的建立，那么如果需要ArrayList数组，需要怎么办？需要先建立指向List的n个引用，然后再依次新建对象。

注意，new后面一定不能带<Integer>之类的参数！！！

{
    List<Integer>[] graph = new ArrayList[n];
    for (int i = 0; i < n; i++) {
        graph[i] = new ArrayList<Integer>();
    }
}

构建大顶堆/小顶堆

Java中PriorityQueue是默认的小顶堆，对于一些复杂的例子，需要自定义Comparator。

// 构建大顶堆
PriorityQueue<Integer> pq = new PriorityQueue<Integer>(new Comparator<Integer>(){
    @Override
    public int compare(Integer o1, Integer o2){
        return o2 - o1;
    }
    });

位移符号

Java中一共有三种位移符号，关于无符号右移，参考题目191. 位1的个数.

1. “>>”。表示有符号位移。负数填充1，正数填充0.
2. “<<”。表示符号左移，全都填充0.
3. “>>>”。表示无符号右移，全部填充0.

StringBuilder相关

StringBuilder去除最后一个字符

参考链接：传送门

一共有两种方法去除末尾的字符，文章里有写.我们使用后者，setLength函数，因为后者不需要copy。

1.使用 deleteCharAt(int index) 函数

public StringBuilder deleteCharAt(int index)

2.使用setLength(int length) 函数

public void setLength(int newLength)

class ListNode<E> {

}