java琐碎

一.case穿透

switch(a){
  case 1:
  case 2:
  case 3:
    sout("YES");
    break;
  default:
    sout("NO");
    break;
}

二.常用api-随机数
application program interface应用程序编程接口，本质就是封装好的类。在同一个包下的类和在java.lang下的类（如string）不用import，其他需要。

Random r=new Random();
//1.int范围内的随机数
int n=r.nextInt();
//2.[0,b)范围内
int n=r.nextInt(b);
//3.[a,b)范围内
int n=r.nextInt(a,b);

三.String and StringBuilder
1.String 可以直接赋值，且省空间，因为赋值的时候会先看看串池中有没有创建过，也可以用空参或者一个实参来创建对象，但费空间。StringBuilder只能使用第二种类构造。
2.字符串和任意数据类型拼起来都是字符串："ss"+123="ss123",1+2+"ss"+1+2="3ss12"。
3.字符串是否相同比较方法：
boolean f1=s1.equals(s2);
boolean f2=s1.equalsIgnoreCase(s2);(不分大小写）
为啥不能s1==s2来判断？因为引用数据类型变量存的是堆内存地址。
那为什么sout能直接输出内容？因为底层用了tostring()转化。
4.Java中字符串不同于字符数组，字符串无法更改,且无法用下标直接访问元素，用char c=s1.charAt(下标)访问。转换成字符数组既可以直接按下标访问，也可修改元素，char a[]=s.toCharArray();
5.数组名.length不需要加括号，s.length()需要。因为在java中，数组并不是一个普通的类，而是JVM（Java虚拟机）在底层直接支持的一种特殊原生结构。创建一个数组时，JVM 会自动在内存中为这个数组分配空间，并直接存储一个名为 length 的公开属性，而字符串中这是一个类方法。
6.子串截取：s=s.substring(起始索引，终止索引);左闭右开，返回子串。
子串替换：s=s.replace(待替换目标，替换成的内容);二者长度不必相同，返回替换后的整个串。
7.是否包含：boolean f=s.contains(s1);
8.判断是否以什么开头或结尾：boolean f1=s.startsWith(s1),f2=s.endsWith(s2);
9.某串第一次或者最后一次出现的索引：int a1=s.indexOf(s1),a2=s.lastIndexOf(s2);没出现过返回-1；
10.大小写转换：s1=s1.toUpperCase();s2=s2.toLowerCase();
11.去除开头末尾空格：s=s.trim();
12.StringBuilder主要用于拼接字符串，因为String不可更改导致拼接时产生大量冗余，而StringBuilder始终在一个串（容器）上拼，更快更省空间。
常用方法：sb.append(s);sb.reverse();s=sb.toString();

四.static(静态，共享）
1.不属于对象，属于类，随着类的加载而加载，一般用类调用。。
2.修饰方法时，javabean类中的方法一般不加，测试类和工具类一般加。
3.工具类无main方法，用来封装一些常用功能，如Arrayutil类，可以封装数组排序方法，找最值方法等等，方法全部static修饰。工具类构造函数修饰private，因为不支持外界创造对象，直接类名调用方法解决需求。
4.静态方法只能访问静态变量和静态方法，因为静态的从属于类，优先对象而存在，非静态的可能还未加载；；而非静态方法显然都可以访问。
5.静态方法没有this关键字。
6.测试类中main方法一般都加static，这也意味着类中其他函数也都加static才行。

五.final（常量）
1.final修饰基本数据类型时，数据只能被赋值一次且无法再修改，变为常量（一般变量名全部大写）。
修饰引用数据类型（数组，字符串，类）时，因为此类变量存的只是堆内存地址，所以只是存地址无法修改，而类中的非final成员变量，数组中的元素，都可以修改。
2.final修饰方法
3.final修饰的类中，方法都不能被重写，且该类不能被继承

六.枚举类（enum）
1.有限个对象在类中全部定义，叫做枚举项。枚举项默认修饰public static final，是常量，用类名调用枚举项。
2.构造函数修饰private，因为枚举类不支持外界另外创造对象。但是定义的所有枚举项在类加载的时候会自动调用构造函数创建完成放在那。

七.继承
1.Java不允许多继承（c++允许），但允许多层继承。分为直接父类和间接父类。
2.有顶级父类Object，“无继承”的类默认继承Object。
3.方法重写与重载不同，重写是方法名以及参数完全与父类方法相同，加上@Override。特别的，final修饰的类中，方法都不能被重写，且该类不能被继承；private，static，final修饰的方法也不能被重写。
4.在访问变量或者方法时，会有重名情况，此时遵循就近原则，（1）直接访问该名就从局部变量开始向上找，到成员变量，到父类变量；this是从成员变量开始找；super是从父类开始找。
5.构造函数不能被继承，子类只能通过super(name,age)来调用，若未写，则默认父类无参构造super()。父类构造函数先执行。
6.
可以理解为：私有-家庭-家族-公共

八.多态
1.将子类对象赋值给父类变量。
2.利用多态调用变量时：编译看左边，运行看左边；调用方法：编译看左边，运行看右边。也就是要想不报错，变量和方法必须在左边父类中出现，只有子类重写方法时，调用的才是子类。
3.由2可知有个弊端是子类独有的不能调用，解决方法是强制类型转换，将父类变量转换为子类。此时常用instanceof来确定转换是对的。
4.instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

九.抽象类和抽象方法(abstract)
1.子类共性方法抽取到父类后，因为子类方法体各不相同，导致父类方法体不能具体确定，此时就可以定义成抽象方法，使父类不再纠结方法体，直接分号代替，且子类必须重写该方法。含有抽象方法的类必须定义为抽象类。
2.抽象类规定不能实例化。
3.有抽象方法的类必须是抽象类，但抽象类不一定有抽象方法，例如一个类没啥意义，只有子类有意义，那就不让他实例化，就设置为抽象类。
4.抽象方法一个好处是强制子类重写避免了多个子类一种功能乱起方法名。

十.接口（关键词interface，用implements来“继承”）
1.接口与类同级，相当于“干爹”，可以同时继承多个接口，干爹可以有多个
2.接口不能实例化
3.成员变量只能是常量，默认public static final修饰。抽象类可以有构造函数，但接口没有构造函数。方法只能是抽象方法（JDK7以前是这样，先这么学着）。
4.父类和接口中的抽象方法都需要重写，但如果有重复的抽象方法，重写一次就行。
5.接口之间可以继承，用extends，那么继承这个接口的类，所有间接接口里的抽象方法都要重写。

十一.内部类
主要学习匿名内部类
1.匿名内部类写在类中，是个没名字的类。
2.主要用于：（1）该类只用一次，再创建java类文件没必要。（2）Lambda表达式前置知识点。
3.格式：
new 父类名或者接口名(){
重写方法;
};
拆解：没有名字的类（大括号内）+继承父类或实现接口+重写方法+new一个对象。

十二.常见集合-ArrayList
1.数组长度不可变，集合长度可变，只能存引用数据类型
2.创建对象：ArrayList<String> list=new ArrayList<>();
3.增：list.add(s);//添加到末尾 list.add(index,s);//添加到索引位置
删：list.remove(s);//根据元素删，只删第一个出现的 list.remove(index);//根据索引删
改：list.set(index,s);
查：list.get(index);
大小：list.size();

十三.工具类-Math类
工具类方法都是静态的，不用创建对象，直接类名调用方法即可。
1.int abs(int a)//绝对值
2.double ceil(double a)//向上取整
3.double floor(double b)//向下取整
4.int round(float a)//四舍五入，注意负数时-1.5会变成-1
5.int max(int a,int b)
6.double pow(double(int) a,double(int) b)
7.double sqrt(double a)

十四.工具类-System
1.void exit(0)//终止Java虚拟机
2.long currentTimeMillis()//返回当前系统时间距离1970年1月1日多少毫秒，1秒=1000毫秒，常用于记录程序运行时间
3.void arraycopy(原数组名，从原数组哪个索引开始拷贝，目的数组名，拷贝到目的数组哪个索引，拷贝个数）

十五.api-包装类
1.就是基本数据类型对应的引用数据类型，int对应Integer，char对应Character，其余的是把首字母大写。这时集合中就可以添加基本数据类型了。
2.创建：Integer i=100;//自动装箱
自动拆箱和自动装箱是其特性，在创建赋值或者进行加减乘除时自动进行。
以下为网络资料：
例一：
Integer a = 100;// 自动装箱，相当于Java编译器替我们执行了 Integer.valueOf(XXX)，该方法返回一个对象。
int b = a;// 自动拆箱，相当于Java编译器替我们执行了Integer.intValue(XXX);
例二：
Integer a = new Integer(100);
Integer b = 100;
b+=100;
第一行代码：new 了一个 Integer 对象实例，将 int 类型的数据传入包装成了 Integer 类型。
第二行代码：首先我们知道 100 是 int 类型的，但是等待复制的 b 是 Integer 类型，此时就用到了自动装箱，b = Integer.valueOf(100)，将100包装成包装类了
第三行代码：用到了自动装箱+自动拆箱，b = b + 100 = Integer.intValye(b) + 100 此时计算结果得到的应该是 int 类型的 b，但是 b 又被限定了是 Integer 类型，所以就又要用到 Integet.valueOf() 自动装箱。

（1）如何理解Java中的自动拆箱和自动装箱？
答：自动装箱就是将基本数据类型自动转换为封装类型，自动拆箱是将封装类型自动转换为基本数据类型。
（2）能说一下是通过哪些方法实现自动拆箱、装箱的吗？
答：以Integer为例，使用Integer.valueOf()方法实现装箱，使用Integer.intValue()方法实现拆箱。
3.常用方法：int parseInt(string s)//字符串转化成整数

十六.BigInteger类
1.创建对象：
（1）若未超出long范围，可以用静态方法获取对象：BigInteger b=BigInteger.valueOf(long);这种有一个优化就是会提前创建好一些常用值的对象。
（2）若超出，只能用构造方法：BigInteger b=new BigInteger(string);
一旦创建，值不可改变，所以下面的方法都是返回一个新对象。
2.常用方法：
BigInteger b3=b1.add(b2);//加
subtract//减 multiply//乘 divide//除
BigInteger b3=b1.max(b2);//获取较大
BigInteger b3=b1.pow(int);//次幂

十七.Decimal类
1.作用：能表示更大的小数，能进行小数的精确计算。
2.创建对象：
（1）若未超出long范围，可以用静态方法获取对象：BigInteger b=BigDecimai.valueOf(double);这种有一个优化就是会提前创建好一些常用值的对象。
（2）若超出，只能用构造方法：BigDecimaib=new BigDecimai(string);
一旦创建，值不可改变，所以下面的方法都是返回一个新对象。
3.常用方法：
加减乘与大数类相同，除法有点麻烦，以后再补。

十八.正则表达式

一般用boolean f=string.matches(s);
注意：\为转义符，那么上面\d这种在敲代码时就得是两个杠把转义功能去掉才行。

十九.爬虫（python更常用）
//获取正则表达式的对象
Pattern p=Pattern.compile("正则表达式");
//获取文本匹配器的对象
Matcher m=p.matcher(str);//m拿着规则p去文本str中找
while(m.find()){
string s=m.group();
sout(s);
}
只演示本地爬取，网络爬取以后再补。
贪婪爬取等问题以后再补。

二十.工具类-Arrays
常用方法：
1.String toString(数组名) //数组转字符串，常用于打印数组
2.int binarySearch(数组名，待查元素）//二分，返回索引，若不存在，返回负的（应插入点）减1，减一是防止待插入点是0，负0还是0
3.void fill(数组名，填充元素) //填充元素
4.void sort(数组名，排序规则) 见下面lambda

二十一.lambda表达式
1.作用：函数式接口的匿名内部类的简化写法。解释：该匿名内部类必须是实现某个函数式接口的，函数式接口就是只有一个抽象方法。
2.下面是sort的例子：