apache和spring都提供了BeanUtils的深度拷贝工具包
+=具有隐形的强制转换
object类的equals()方法容易抛出空指针异常
String a=null;
/*使用a.equals(b)抛出异常
优化方法1，若b为常量，即a.equals("test")
此时调用"test".equals(a)可避免空指针错误
优化方法2，使用Objects工具类：java.util.Objects
调用Objects.equals(a,b)可避免空指针错误
*/cal.get(Calendar.MONTH)从零开始返回，也就是说January（一月）返回0，因此int month = cal.get(Calendar.MONTH)+1才是正确月份；同时，cal.get(Calendar.DAY_OF_WEEK)是从周日开始，返回1，周一返回2，因此该值-1才是正确星期，同时还需要判定是否为周日（真难用）处理星期可以使用一个从周日开始的String[ ]数组，直接使用String[ i-1 ]来进行输出（舒服点了）
jvm有String常量池（注意是 常 量 池，常量。盯久了不认识这俩字了），但是new String对象是在堆中的，new String拼接也是在堆中，不在常量池，字符串还有个inertn()方法，用于获取常量池引用：s2=s1.intern()，此时s1==s2为true
DateFormat为抽象类，格式化处理日期使用SimpleDateFormat类
Calendar类内部维护了一个fields[]数组，存储时间信息，get()方法传入的常量值就是数组下标。如cal.get(Calendar.YEAR)和cal.get(1)是一样的（CalendarYEAR 值为 1）
基本类型快速转化字符串可以加空字符串。如Sting s=1+"";
method ( int... arr )可变参数，不用构件数组而是直接传递多个参数。如void method(int... arr);method(1,2,3,4);
栈（也叫虚拟机栈）、堆，方法区，寄存器（也叫程序计数器），本地方法栈
栈：Java栈中存放的是一个个的栈帧，每个栈帧对应一个被调用的方法。因此递归很容易爆栈233333.
堆：存放数组与对象，对象不被引用之后会被垃圾回收。
方法区：保存.class文件，常量池，（还有静态方法？）
具体可以看这个博客，写的很清楚。
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
总结：重写compareTo(Object ob)方法时，ob为第一个元素，this是后一个元素。因此，this-ob即为升序（与默认相同），如果是引用类型，直接调用compareTo方法（默认升序，想降序在前面加 - 返回反数即可）。compare()方法同理，第一个参数为后面的元素，第二个参数为前面的元素，因此，o1-o2为升序，o2-o1为降序（这两个函数返回值的意义为：整数：表示大于，0表示等于，负数表示小于）
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int result = o2.getAge()-o1.getAge();//以学生的年龄降序
//可以编写多个规则：
/*
if(result==0){//第一个规则相同时 下一个规则 姓名的首字母 升序
result = o1.getName().charAt(0)-o2.getName().charAt(0);
}
*/
return result;
}
});
/*这里，注意，o1是后面的元素，o2是前面的元素
返回 1、0 表示不交换，-1表示交换，同理正数和0不交换，负数交换。
*/
//lambda
Collections.sort(list, (o1, o2) -> {
return o2.getAge()-o1.getAge();
});list、set转数组：
List<String> list = new ArrayList<String>();
/*list.toArray()无参方法返回Object数组，用Object[]接收强转会抛异常；
list.toArray(数组)：
若数组长度小于list长度，转化失败，数组内容不变；
若长度相等，则正好转化；
若数组长度大于list长度，可以转化，但是最后一个元素的下一个会被赋null，也就是
数组[list.size()]这个位置会被赋null；
*/
String[] array=list.toArray(new String[list.size()]);数组转list、set：
List<String> list = new ArrayList<>(Arrays.asList(array));
Set<String> set = new HashSet<>(Arrays.asList(array))
//或者使用Collections.adAll()方法：
List<String> list = new ArrayList<String>(array.length);//list
Set<String> set = new HashSet<String>(array.lenth);//set
Collections.addAll(list, array);
Collections.addAll(set,array);list、set互转：
Set<String> set = new HashSet<>(list);
List<String> list = new ArrayList<>(set);
//毕竟都是Collection┓(?′?`?)┏用流装箱拆箱还不是太明白，以后再看吧。
上面三种方式不能用于基本类型，因此需要对基本类型数组装箱拆箱，可以使用JDK8的Stream方式
Integer[] ints= IntStream.of(arr).boxed().collect(Collectors.toList()).toArray(new Integer[0]);List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());（这里是错的，不是所有的基本类型，试了下char和boolean数组不能用，int和double可以，具体什么原因以后再更）
一种方式是转化list，使用Collections.shuffle(list)进行打乱，另一种方式是：
从数组的最后一个位置（假设下标是n）开始向前扫描，然后随机生成一个0到n之间的随机数（这里必须包括n，不然最后一个数一定会变），假设该随机数是r1，然后将数组最后一个位置（下标n）与r1位置互换，之后开始扫面下一个数（下标为n-1），然后随机生成一个0到(n-1)之间的随机数，假设该随机数是r2，然后将数组倒数第二个位置（下标为n-1）与r2位置互换，然后继续扫面下一个数（下标为n-2），就这样一直迭代下去。在这个迭代过程中，可以保证扫面点左边的数字都是尚未确定位置的，而右边的数字都是已经安排好位置的。
//若为基本类型则修改掉泛型即可
public static <T> void shuffle(T[] arr) {
for (int i = arr.length; i > 0; i--) {
int r = new Random().nextInt(i);//取值0到lenth-1
T temp = arr[i - 1];
arr[i - 1] = arr[r];
arr[r] = temp;
}
}遇见个挺简单的题，但是由这个题扩展出许多有意思的东西包括上面的装箱和数组打乱
做题记录
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
/*
十二、双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择；
蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）//这里我理解错了，以为是所有球号码不能重复，所以代码是所有号码不重复的情况
*/
public class Test12 {
public static void main(String[] args) {
// Integer[] nums = makeBalls();这是第一种方法
int[] nums = makeballs2();
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + " ");
}
}
//思路1：用数组双循环判定是否重复
//思路2：这里使用了set的不能重复的性质
//用Integer[]代替int[]，因为set转数组时不能为基本类型
public static Integer[] makeBalls() {
Set<Integer> balls = new HashSet<>();
while (balls.size() < 6) {
balls.add(new Random().nextInt(33) + 1);
}
while (balls.size() < 7) {
balls.add(new Random().nextInt(16) + 1);
}
return balls.toArray(new Integer[balls.size()]);
}
//思路3：使用Arrays.binarySearch(数组，Key)判定是否重复
//但是使用数组放入球的顺序很重要
public static int[] makeballs2() {
int[] balls = new int[7];
for (int i = 0; i < balls.length; i++) {
if (i == 0) {
balls[i] = new Random().nextInt(16) + 1;
continue;
}
int num = new Random().nextInt(33) + 1;
//Arrays.sort(balls);排序会打乱顺序，就不能用i操作复制了，正常使用需要配合排序
int some =Arrays.binarySearch(balls, num);
if (some > 0) {
i--;
} else {
balls[i] = num;
}
}
//球放进去之后打乱，list可以使用Collections.shuffle(list)进行打乱
//至于数组打乱见shuffle方法
// shuffle(IntStream.of(balls).boxed().collect(Collectors.toList()).toArray(new Integer[0]));
shuffle2(balls);
return balls;
}
public static <T> void shuffle(T[] arr) {
for (int i = arr.length; i > 0; i--) {
int r = new Random().nextInt(i);//取值0到lenth-1
T temp = arr[i - 1];
arr[i - 1] = arr[r];
arr[r] = temp;
}
}
public static void shuffle2(int[] arr) {//这样就不用装箱了
for (int i = arr.length; i > 0; i--) {
int r = new Random().nextInt(i);//取值0到lenth-1
int temp = arr[i - 1];
arr[i - 1] = arr[r];
arr[r] = temp;
}
}
}同时知道了Arrays.binarySearch()的用法，这里贴两个链接，写的挺清楚的链接1和链接2
Set判断元素是否重复通过调用被添加元素的hashCode()方法，因此，对于自定义类，需要重写hashCode()和equals()方法
调用被添加元素的hashCode()，和HashSet中已有元素的hashCode比较是否相同
如果不相同，直接存储
如果相同，调用equals方法比较是否相同
不相同，直接存储元素
相同，认为是同一元素.不存储
//这里是个Human类，有name,age成员变量
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Human so = (Human) o;
return (name.equals(so.name) && age == so.age);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}原文：https://www.cnblogs.com/lixin-link/p/10991694.html