1、基本类型（存放在栈中）转换成字符串类型

（1）包装类的toString()方法
（2） String 类的valueOf()方法，注意：当入参为基本类型：int、long、float、double时，此方法实现实际为调用了对应包装类的toString()方法。Integer.toString、Long.toString、Float.toString、Double.toString
（3）空字符串加一个基本类型变量，即x+""

2、字符串类型转基本类型，如int

（1）包装类的parse***()静态方法，Interger.parseInt(String)
（2）包装类的valueOf()方法，Interger.valueOf(String).intValue()

3、Arrays.sort 和Collections.sort比较

Arrays.sort
Arrays.sort 针对任意对象，排序的类型就为传入的对象类
如：Arrays.sort(a)//这里a为数组，可以是 int/String /类数组，排序类型依次为int ,String ，类

总结:
lenthth<47 插入排序
47<length<286 双轴快速排序
length>286 且连续性不好双轴快速排序
length>286 且连续性好归并排序

Collections.sort
Collections.sort 针对集合（List）,排序类型为List对应的类型
如：Collections.sort (l)//这里l为List 对象，可以为List< Integer>/List< String>/List<类> ，排序类型依次为Integer,String ,类

4、System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

5、泛型通配符

https://juejin.im/post/5d5789d26fb9a06ad0056bd9
本质上这些个都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的 T ，我们可以换成 A-Z 之间的任何一个字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常Java泛型中的标记符含义：
E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的java类型
S、U、V - 2nd、3rd、4th types

6、List和int[]互转

List->数组

List<String> list = new ArrayList<String>(Arrays.asList("are","you","ok","?"));
String[] array = new String[list.size];
list.toArray(array);

JDK1.8：

List<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6));
int[] array = list.stream().mapToInt(x->x).toArray();

数组->List

String[] array = {"are","you","ok","?"};
List<String> list = new ArrayList<String>(Arrays.asList(array));

JDK1.8：

int[] array = {1,2,3,4,5,6};
List<Integer> list = Array.stream(array).boxed().collect(Collectors.toList());

Arrays.stream(arr) 可以替换成IntStream.of(arr)。
1.使用Arrays.stream将int[]转换成IntStream。
2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
3.使用Stream的collect()，将Stream<T>转换成List<T>，因此正是List<Integer>。
拓展：
int[] 转 Integer[]

Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);

前两步同上，此时是Stream<Integer>。
然后使用Stream的toArray，传入IntFunction<A[]> generator。
这样就可以返回Integer数组。
不然默认是Object[]。
List<Integer> 转 Integer[]

Integer[] integers2 = list1.toArray(new Integer[0]);

调用toArray。传入参数T[] a。这种用法是目前推荐的。
List<String>转String[]也同理。
List<Integer> 转 int[]

int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();

想要转换成int[]类型，就得先转成IntStream。
这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
而IntStream中默认toArray()转成int[]。
Integer[] 转 int[]

int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();

思路同上。先将Integer[]转成Stream<Integer>，再转成IntStream。
Integer[] 转 List<Integer>

List<Integer> list2 = Arrays.asList(integers1);

最简单的方式。String[]转List<String>也同理。

// 同理
String[] strings1 = {"a", "b", "c"};
// String[] 转 List<String>
List<String> list3 = Arrays.asList(strings1);
// List<String> 转 String[]
String[] strings2 = list3.toArray(new String[0]);

7、List用Stream 求和

package test;  
  
import java.util.Arrays;  
import java.util.List;  
import java.util.Optional;  
  
public class Test {  
    public static void main(String[] args) {  
  
        List<Integer> strs = Arrays.asList(1,2,3,4,5,6);  
          
        //方式一：求和  stream().reduce
        Optional<Integer> sum = strs.stream().reduce((x, y) -> x + y); //(x, y) -> x + y 同 Integer::sum
        System.out.println("reduce 求和方式1:" + sum.get());

        //方式二： stream().reduce
        Integer sum2 = strs.stream().reduce(0, (x, y) -> x + y);
        System.out.println("reduce 求和方式2:" + sum2);

        //方式三：stream().mapToInt ；流的.sum()方法仅支持原始类型流如int[]，这样要用mapToInt方法转换至IntStream
        Integer sum3 = strs.stream().mapToInt((x) -> x).sum(); // mapToInt((x) -> x)同mapToInt(Integer::intValue)
        System.out.println("mapToInt+ sum求和方式:" + sum3);

        // 方式四：stream().collect     此方法IDEA推荐使用方式三
        Integer sum4 = strs.stream().collect(Collectors.summingInt(x->x));
        System.out.println("Collectors.summingInt求和方式:" + sum4); 
          
  
    }  
  
}

运行结果：
reduce 求和方式1:21
reduce 求和方式2:21
mapToInt+ sum求和方式:21
Collectors.summingInt求和方式:21
拓展
int[]可如下求和

public static int findSumUsingStream(int[] array) {
    return Arrays.stream(array).sum();
}

流方式求平均值

public static double findAverageUsingStream(int[] array) {
    return Arrays.stream(array).average().orElse(Double.NaN);
}

IntStream.average方法返回OptionalDouble，可能不包含值，所以需要指定一个特定值。

8、求数组最大值或最小值下标

int[] a = {8, 6, 3, 10};            
int minIndex = IntStream.range(0, a.length).reduce((i, j) -> a[i] > a[j] ? j : i).getAsInt();

9、线程安全的集合类

Vector
Stack
Hashtable
java.util.concurrent包下所有的集合类
ArrayBlockingQueue、ConcurrentHashMap、ConcurrentLinkedQueue、ConcurrentLinkedDeque...

Java数据相关