Java基础查漏补缺（2）
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为trueDateFormat为抽象类，格式化处理日期使用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);
JVM内存分布
栈（也叫虚拟机栈）、堆，方法区，寄存器（也叫程序计数器），本地方法栈
栈：Java栈中存放的是一个个的栈帧，每个栈帧对应一个被调用的方法。因此递归很容易爆栈233333.
堆：存放数组与对象，对象不被引用之后会被垃圾回收。
方法区：保存.class文件，常量池，（还有静态方法？）
具体可以看，写的很清楚。
Comparable和Comparator
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() { @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不交换，负数交换。 *///lambdaCollections.sort(list, (o1, o2) -> { return o2.getAge()-o1.getAge();});
List、Set和数组互转
list、set转数组：
List
list = new ArrayList ();/*list.toArray()无参方法返回Object数组，用Object[]接收强转会抛异常； list.toArray(数组)： 若数组长度小于list长度，转化失败，数组内容不变； 若长度相等，则正好转化； 若数组长度大于list长度，可以转化，但是最后一个元素的下一个会被赋null，也就是 数组[list.size()]这个位置会被赋null； */String[] array=list.toArray(new String[list.size()]); 数组转list、set：
List
list = new ArrayList<>(Arrays.asList(array));Set set = new HashSet<>(Arrays.asList(array))//或者使用Collections.adAll()方法：List list = new ArrayList (array.length);//listSet set = new HashSet (array.lenth);//setCollections.addAll(list, array);Collections.addAll(set,array); list、set互转：
Set
set = new HashSet<>(list);List 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可以，具体什么原因以后再更）
用Stream处理int数组
更新：使用Stream进行拆装箱
import java.util.Arrays;import java.util.List;import java.util.stream.Collectors; public class Main { public static void main(String[] args) { int[] data = {4, 5, 3, 6, 2, 5, 1}; // int[] 转 List List list1 = Arrays.stream(data).boxed().collect(Collectors.toList()); // Arrays.stream(arr) 可以替换成IntStream.of(arr)。 // 1.使用Arrays.stream将int[]转换成IntStream。 // 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream 。 // 3.使用Stream的collect()，将Stream 转换成List ，因此正是List 。 // int[] 转 Integer[] Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new); // 前两步同上，此时是Stream 。 // 然后使用Stream的toArray，传入IntFunction generator。 // 这样就可以返回Integer数组。 // 不然默认是Object[]。 // List 转 Integer[] Integer[] integers2 = list1.toArray(new Integer[0]); // 调用toArray。传入参数T[] a。这种用法是目前推荐的。 // List 转String[]也同理。 // List 转 int[] int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray(); // 想要转换成int[]类型，就得先转成IntStream。 // 这里就通过mapToInt()把Stream 调用Integer::valueOf来转成IntStream // 而IntStream中默认toArray()转成int[]。 // Integer[] 转 int[] int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray(); // 思路同上。先将Integer[]转成Stream ，再转成IntStream。 // Integer[] 转 List List list2 = Arrays.asList(integers1); // 最简单的方式。String[]转List 也同理。 // 同理 String[] strings1 = {"a", "b", "c"}; // String[] 转 List List list3 = Arrays.asList(strings1); // List 转 String[] String[] strings2 = list3.toArray(new String[0]); }} 参见
数组打乱
一种方式是转化list，使用Collections.shuffle(list)进行打乱，另一种方式是：
从数组的最后一个位置（假设下标是n）开始向前扫描，然后随机生成一个0到n之间的随机数（这里必须包括n，不然最后一个数一定会变），假设该随机数是r1，然后将数组最后一个位置（下标n）与r1位置互换，之后开始扫面下一个数（下标为n-1），然后随机生成一个0到(n-1)之间的随机数，假设该随机数是r2，然后将数组倒数第二个位置（下标为n-1）与r2位置互换，然后继续扫面下一个数（下标为n-2），就这样一直迭代下去。在这个迭代过程中，可以保证扫面点左边的数字都是尚未确定位置的，而右边的数字都是已经安排好位置的。
//若为基本类型则修改掉泛型即可 public staticvoid 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 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 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()的用法，这里贴两个链接，写的挺清楚的和
- IDEA在debug模式下用Alt+F8可以打开Evaluate Expression计算表达式窗口，可以动态获取某一个值（这是个神器！）
Set
Set判断元素是否重复通过调用被添加元素的hashCode()方法，因此，对于自定义类，需要重写hashCode()和equals()方法
调用被添加元素的hashCode()，和HashSet中已有元素的hashCode比较是否相同
如果不相同，直接存储 如果相同，调用equals方法比较是否相同 不相同，直接存储元素 相同，认为是同一元素.不存储
//这里是个Human类，有name,age成员变量 @Overridepublic 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);}@Overridepublic int hashCode() { return Objects.hash(name, age);} int[] arr;arr = {1, 2};//这种初始化形式只有在声明的时候才能用（之前没注意到这点）//这种是对的int[] arr = {1,2};//这种也是可以的int[] arr2;arr2 = new int[]{1,2,3}; 实现Runnable接口必须实现无参无返回值的run()方法
主方法中String[] args的意思是Java程序在运行的时候可以传参，比如
public class Test { public static void main(String[] args) { for (int i = 0; i < args.length; i++) { System.out.println(args[i]); } }} 在控制台执行 javac Test.java编译
java Test AAA BBB CCC运行 运行结果会是： AAA BBB CCC 即三个参数会在main方法运行前传入args数组this在Java中属于一个隐式变量，记录着调用当前方法的对象的地址
使用迭代器迭代list时，修改list会抛出ConcurrentModificationException异常
//数组遍历有删除操作时需要i--进行回溯//这种数组型的遍历并不能完全移除for (int i = 0; i < list.size(); i++) { if (list.get(i).equals("b")){ list.remove(i); //i--;//加入i--回溯可以移除 }}// 倒序遍历是可以的，因为判定值与长度无关，但是不推荐for (int i = list.size() - 1; i >= 0; i--) { if (list.get(i).equals("b")){ list.remove(i); }}//更优雅的是使用流~System.out.println(list.stream() .filter(s -> !s.equals("b")) .collect(Collectors.toList()));//赏心悦目~list.remove("b");//移除第一个找到的"b"//使用迭代器迭代list时，修改list会抛出ConcurrentModificationException异常for (String s : list) { if (s.equals("b")) { list.add("d"); list.remove(s); }} String[] arr = {"D","B","A","B","C","A","A","B","D","C","D","D"};Stream stream = Arrays.stream(arr).limit(5);List list = stream.collect(Collectors.toList());//这里会抛出异常，因为流是不能被重用的！！！String[] strings = stream.toArray(String[]::new); 集合不能存储基本类型，只能存储引用类型
Scanner的nextLine和nextInt一般不要混用，因为：nextLine遇到回车结束；nextInt遇到回车结束后会留下一个空格。因此混用时需要在nextInt下面再放一个nextLine来读取留下的那个空格
return可以结束方法，或者System.exit(0)结束虚拟机- 可以使用
\t在控制台输出规整的字符 - Pattern和matcher的简单实用（）：
- Pattern对象由静态方法：
Pattern.compile(regex)创建， - Pattern对象有个
matcher(string)方法，参数为需要匹配的字符串，该方法返回Matcher对象 - Matcher对象有三个主要方法，
matches(),lookingAt(),find()matches()返回布尔值，匹配整个字符串，也就是说整个字符串都需要符合正则规则，才会返回truelookingAt()返回布尔值，从开头匹配，也就是说开头有符合正则的，就会返回truefind()返回布尔值，只要发现符合正则规则的，就会返回true
- 也就是说，一个快捷的匹配方式为
Pattern.compile(regex).matcher(string).find()就可以知道string里是否含有regex的字符串了。 - Matcher有个成员方法
group()，可以返回匹配到的字符串，以及start()和end()方法获得匹配到的字符串的开始和结束的下标。（想要matcher.group()方法，必须先matcher.find()方法，切忌！要不然总是报错） - 只有当匹配操作成功,才可以使用
start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用。
- Pattern对象由静态方法：
properties.load(new FileInputStream(path))load方法执行后其参数流是打开状态。