1.语言基础
二进制操作
“&”按位与：a与b同时为1结果为1，否则为0；
“|”按位或：a与b其中任一个为1，否则为0
“~”按位取反
“^”按位与或：a与b值相同(同为0或1)时为0，否则为1
“<<”左移：右边以0来补充
“>>”右移：左边第1位相同值来补全，右边抛弃
“>>>”无符号右移：左边高位以固定值0补全
技巧：一个数左移n位，结果为这个数乘以2n ; 一个数右移n位，结果为这个数除以2n
2.循环控制
foreach写法
int[] ids=new int[]{1,2,3};
for (int i : ids) {
System.out.print(i);
}循环退出break是退出内层，多层的循环退出，可使用：break 标签;
first_label: for(int i=0;i<10;i++) {
for(int j=0;j<12;j++) {
if(j==10) {
break first_label;
}
}
}
3.字符串
字符串对比可以==，但字符对象要用equals或equalsIgnoreCase
String name="a";
String name2="a";
System.out.print(name==name2);//结果true
String w=new String("a");
String w2=new String("a");
System.out.print(w==w2);//结果false
System.out.print(w.equalsIgnoreCase(w2));//结果true
replace字符时要注意大小写，区分大小写的；
split可以限制切割次数：aString.split(",",2);
格式化：String s=String.format("格式",变量);
正则匹配
String tt="dav";
String regex="\w{0,}";
System.out.print(tt.matches(regex));//是否匹配
String tt="d33ddav234";
Pattern pattern=Pattern.compile("\d");
Matcher mt=pattern.matcher(tt);
while(mt.find()) {
System.out.print(mt.group(0));//结果33234
}
StringUtils有丰富的字符操作方法，需要导入commons-lang-2.6.jar，引用import org.apache.commons.lang.StringUtils;
4.数组
初始化：int bb[]=new int[]{1,2,3};
使用Arrays.fill()填充或替换值
String bb[]=new String[]{"1","2","3"};
Arrays.fill(bb, 1,3,"99");
//bb[1]="ggg";
System.out.print(String.join(",",bb));//结果1,99,99
Arrays.sort(数组)：排序
Arrays.binarySearch():查找返回索引，不存返回-1或-。在使用此之前必段使用Arrays.sort进行排序
冒泡算法（邻居相比的方式）
int items[]=new int[] {1,45,4,65,5,60};
for (int i = 0; i < items.length; i++) {
for (int j = 0; j < items.length-1; j++) {
int a=items[j];
int b=items[j+1];
if(a>b) {
items[j+1]=a;
items[j]=b;
}
}
}
直接选择算法：与冒泡相比，最大不同，就是把最大的放最后再循环剩下的，更快速
int items[] = new int[] { 1, 45, 4, 65, 5, 60 };
int index;
for (int i = 1; i < items.length ; i++) {
index = 0;
for (int j = 1; j <= items.length - i; j++) {
if(items[j]>items[index]) {
index=j;
}
}
var temp=items[items.length-i];
items[items.length-i]=items[index];
items[index]=temp;
}
反转排序：把一个排序倒过来，只需要循环对半的次数就行
int items[] = new int[] { 1, 45, 4, 65, 5, 60 };
int len = items.length;
for (int k = 0; k < len / 2; k++) {
int temp = items[len - 1 - k];
items[len - 1 - k]=items[k];
items[k]=temp;
}
5.类与对象
封装、继承、多态(同一抽象或接口在各自实现时可以有不同的行为)
final:常量
private:类自身可见 protected:仅同一包内可见 public：都可见
技巧：
public class Test {
static {
// 该模块内会被最先执行，且只执行一次
}
}
6.包装类
7.数字处理
格式化：
double d=1234567.89;
DecimalFormat df=new DecimalFormat("###,###.##");
//df.applyPattern("###,###.##");//另一种非构造方法的写法
print(df.format(d));
Math常用运算方法
Math.ceil(double a):大于等于参数的最小整数，即向上取整
Math.floor(double a):小于等于参数的最大整数，即向下取整
Math.rint(dobule a):与参数最接近的整数，如果存在两个同为接近的整数，则取偶数
Math.max(a,b):取最大值
Math.min(a,b):取最小值
Math.abs:绝对值
Math.random()：随机0.0~1.0之间的double型数字
随机类
Random random=new Random();
print(random.nextInt(88888)+"");
大数字运算：BigInteger BigDecima
BigInteger arg=new BigInteger("2");
BigInteger bi=new BigInteger("456");
bi.add(arg);//做加法
bi.subtract(arg);//减法
bi.multiply(arg);//乘法
bi.divide(arg);//除法
bi.remainder(arg);//取余
bi.divideAndRemainder(arg);//用数组返回余数和商，数组第一个为商，第二个为余数
bi.pow(3);//3次方的操作
bi.negate();//相反数
bi.shiftLeft(2);//左移两位
bi.shiftRight(2);//右移两位
bi.and(arg);//与操作
bi.or(arg);//或操作
bi.compareTo(arg);//对比，bi>arg大于0 ;小于为<0;相等0
8.接口、继承、多态
extends:继承 super调用父类
继承可以重写父类的权限，只能提升不能降，由private升protected/public可以，反之不行；
继承的返回值可以与父类不一致，但子类返回值类型须为父类的返回值的子类；
实例化子类时会先实例顶级父类无参构造方法，最后才是子类；因此子类调用finalize()清理对象时最后一个动作是调用父类的finalize()。
Object
所有类都继承于Object;getClass()返回对象执行时的Class实例；
==是比较两者的引用(地址)是否相等，equals是比较两者的实际内容是否相等；但对于自定义类的两个实例使用equals是false.因为自定义类的equals默认使用==来比较的,因此自定义类的比较要重写equals;
多态
同父类或接口的方法子类可以有不同实现方法。 如 父类 a=new 子类(), 灵活点是使用父类去做结构，到处满天飞，很灵活，扩展方便。
子向父转换是向上转换，如父 a=new 子(); 父向子转为向下转换，要显式声明,如 子 a=(子)父，且父是通过子实例化出来的才行，因此要习惯在向下转换时做一下判断 if(父 instanceof 子)；
抽象与接口
抽象类与方法使用abstract修饰，接口用interface修饰
接口是抽象类的延伸，换句话说使用抽象无法完全解决问题，适当引用接口来协助完成。例如，抽象类的一个方法是子类所需，但并不是所有子类都需要，如果放在抽象类里面，不需要的子类也要实现该方法，有冗余，且在一个类无法继承多个类的情况下，引入接口就能解决，把该方法定义在一个接口里，需要的类继承即可。所以说接口是抽象类的补充延伸，仅协助抽象类。
接口中的任何字段都自动是static和final的。
一个类继承多个接口写法： class 类名 implements 接口1,接口2。。。
9.类高级特性
JAVA包
包命名全部使用小写字母
定义类所在的包写法 package com.lze; 导入写法，在类中引入import com.lzw.*;
import还可以导入静态方法和静态变量：
import static java.lang.Math.max;
import static java.lang.System.out;
out.print(max(1,4));//使用方法
final常量
final常量名要以全部大写，单词间用_分隔；
final常量在声明时给了值，则无法再变更，若声明时为空，则可以在构造方法里赋值；
声明final为引用(类),则可以该实例里面的属性赋值，但不能把 final重新指向另一个实倒；
声明 final为数组时，里面的数组项不能再被更改值。如a[2]=”sdf”是错误的；
static final 常量名，则是无论实例多少次，此值都是第一次实例时的值，且不可更改；
final方法不能被重写与覆盖；
final类不能被继承；
内部类
内部类可以任意调用外部类的方法与字段，即时使用private修饰；
外部类要调用内部类，必须在外部类里实例化内部类再调用 ；
内部类的实例化必须在外部类或外部类的非静态方法中实现；其他类想调用某类的内部类，必须要先有外部类的实例，并在此实例下再调用内部类；
内部类使用 private修饰，很好的隐藏；
内部类可以继承其他类，也可以实现接口且一个类可以有N个内部类，因此相当于间接实现了一个类继承多个类的方式，这是使用内部类的最大理由！
内部类可以定义在一个类的一个方法的任何地方。
匿名内部类写法：
public ITest getInterface(){
//匿名内部类写法
//ITest可以是类，也可以是接口
return new ITest() {
@Override
public void pick() {
System.out.print("我是匿名");
}
};
}
静态内部类很少使用到，静态内部类不能调用外部类的非静态成员；
内部类的继承：
10.异常处理
Exception e ,变量e有三个常用方法：
e.getMessage():输出错误性质
e.toString():给出异常的类型与性质、栈层次及出现错误的位置
/**
* 定义自定义错误
*/
public class MyException extends Exception {
private String _message;
public MyException(String message) {
_message = message;
}
public String toString() {
return _message;
}
public String getMessage() {
return _message;
}
}
//throws MyException 为错误向上抛
public void testError() throws MyException {
throw new MyException("自定义错误内容");
}
11.集合类
Collection<String> liStrings = new ArrayList<String>();
liStrings.add("0");
liStrings.add("11");
Iterator<String> iterator=liStrings.iterator();
while(iterator.hasNext()) {
String str=(String)iterator.next();//值为Object,要显式转换为String
print(str);
}
List集合
可以插入重复的元素,null也可以，且是按插入顺序排列。
两个常用方法: get(index)->获取指定索引的元素；set(index,Object)->指定位置修改为object
两个常用实现:
ArrayList：通过索引位置可以快速随机访问。缺点是插入和移除速度较慢；
LinkedList:优点集中写入或移除时速度快，缺点是随机访问较慢。
Set集合
Set集合是按不特定的方式排序，且是不能包含重复元素。
HashSet:由哈希表支持，实质是HashMap的实例，不保证迭代顺序，顺序不保证恒久不变，支持null元素；
TreeSet:在遍历该集合时是按照自然顺序递增排序的，也可以按照指定比较器递增排序，不支持null。
TreeSet常用方法有：
first():当前第一个元素
last():最后一个元素
comparator():返回比较器，如果是默认的自然顺序，则返回null
headSet(参照元素)：返回一个新集合，集合值为是参照元素所在位置之前的所有元素组成，不包含参照元素。
subSet(参照开始元素,参照结束元素):返回一个新集合，值为参照开始元素(包含)至参照结束元素(不包含)之间元素组成。
tailSet(参照元素)：返回一个新集合，值为参照元素(包含)之后所有元素
技巧：包不包括参照元素，可以看参数元素是否为新的集合的第一条记录，若是则包含。
下面为实现比较器的写法：
//实现Comparable
public class Student implements Comparable<Student> {
private int id;
private String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
//重写比较
@Override
public int compareTo(Student arg0) {
if (arg0.id > id)
return -1;
else if (arg0.id < id)
return 1;
return 0;
}
public String getName() {
return name;
}
}
调用：
Student a=new Student(20,"小A");
Student b=new Student(10,"小b");
Student c=new Student(50,"小c");
Student d=new Student(30,"小d");
TreeSet<Student> set=new TreeSet<Student>();
set.add(a);
set.add(b);
set.add(c);
set.add(d);
Iterator setIterator=set.iterator();
while (setIterator.hasNext()) {
Student student=(Student)setIterator.next();
print(student.getName()+"====");
}
//结果小b====小A====小d====小c====
Map集合
Map是key/value的字典，key不允许重复;
HashMap:一般建议使用HashMap,添加或移除和查找速度快，但不保证顺序；
TreeMap:有一定的顺序排列，如同TreeSet一样，也不支持值为null;
建议使用方式，可以先使用HashMap创建和添加数据，如果需要用到排序的再创建一个相同的TreeMap(如使用putAll()方法)；
常用方法：
put(key,value):添加
containsKey(key):判断是否存在key
containsValue(value):判断是否存在此value
get(key):返回值，不存在则返回null
keySet():获取key的set集合
values():获取值的Collection集合
12.I/O(输入/输出)
I/O即是Input/Output
理解流概念，从文件/压缩包/网络通过数据流传到目的地为输入流，从源通过数据流传到文件是输出。
InputStream(字节输入流) OutputStream(字节输出流)
Reader(字符输入流) Writer(字符输出流)
通常来说一个字符为两个字符，不同编码存在不同，所以字符输入输出更适合用于处理文本。
Reader是继承InputStream，是做了简化处理；Writer亦如此。Reader/Writer处理数据时是以InputStream/OutputStream为基础；
输入流
InputStream是所有输入流的父类，为抽象类
输入流常方法：
read():从此输入流中读取下一个数据字节,返回一个 0 到 255 范围内的 int 字节值,如果因为已经到达流末尾而没有字节可用，则返回 -1。在输入数据可用、检测到流末尾或抛出异常之前，此方法将一直阻塞。(可定义一个数组保存循环获取的结果)
read(byte[指定长度] b)：读取指定长度的字节保存到b里面去，会阻塞。
available():返回此输入流不受阻塞地读取的剩余字节数
skip(long n):跳过n个字节，返回值为跳过的实际字节数
close():关闭，最后一定要关闭
输出流
OutputStream是所有字节输出流的超类，类中所有方法均返回void
输出流常用方法：
write(int b):将指定的字节写入此输出流
write(byte[] b):把数组b写入此输出流
write(byte[] b ,int off,int len):在b中的off处开始拿len个字节写入引输出流
flush():彻底完成输出并清空级存区
close():关闭输出流
File类
File file=new File(“aa.txt”);//有很多重载方法
file.exists();//是否存在
file.createNewFile();//创建
file.isFile();//是否为标准文件
file.isDirectory();//是否为目录
文件输入/输出流
FileInputStreamFileOutputStream是字节流；FileReaderFileWriter是字符流；有中文字符更适合使用后者。
File file = new File("aa.txt");
try {
FileOutputStream out = new FileOutputStream(file);
byte str[]="我是测试的内容".getBytes();
out.write(str);//写入到输出流
out.flush();
out.close();
byte readResult[]=new byte[str.length];
FileInputStream in=new FileInputStream(file);
in.read(readResult);//读取到数组
in.close();
print(new String(readResult));//从数组转为String并打印
FileWriter fw=new FileWriter(file);
fw.write("我是测试filewriter");
fw.flush();
fw.close();
char rstr[]=new char[str.length];
FileReader fr=new FileReader(file);
fr.read(rstr);
fr.close();
print(new String(rstr));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}带缓存的输入输出流
BufferedInputStream是对所有InputStream类进行带缓存区的包装，以达到性能优化。
在实例BufferedInputStream/BufferedOutputStream时仅多了一个指定缓存字节的参数
new BufferedInputStream(InputStream in)//默认为32字节缓存区
new BufferedInputStream(InputStream in,int size)//指定size字节缓存区
BufferedOutputStream调用flush()是强制即时输出，调用 close()时也会自动将缓存刷新到磁盘文件
BufferedReader常用方法：
read():读取单个字符.
readLine():读取一个文本行，若无数据可读时，则返回null(这一点可以循环读取每一行做是否读取完的判断)
BufferedWriter常用方法：
write(String s,int off,int len):写入某一字符串某一部分
flush():刷新流缓存
newLine():写入一个行分隔符
BufferedWrite调用write()时并没有立即写入出输出流，而是首先进入缓冲区，只有调用flush ()才写入。
数据输入输出流
DataInputStream/DataOutputStream允许与机器无关的方式从底层读取基本java数据类型。即不用关心读取数据是哪种字节。
DataOutputStream提供了：-
writeBytes(String s); writeChars(String s); writeUTF(String s);
但DataInputStream只提供了ReadUTF()方法，以所上面三个一起写入到一个文件中，ReadUTF()只返回writeUTF写的内容，其他忽略。
ZIP压缩输入/输入出流
使用ZipOutputStrean/ZipInputStream进行压缩/解压
ZipOutputStrean使用点就是使用putNextEntry(new ZipEntry(filePath))为压缩包添加文件或目录的，如下面完整代码
public static void main(String args[]) {
zipFile("D:\test");
}
public static void zipFile(String filePath) {
File file = new File(filePath);
try {
ZipOutputStream out = new ZipOutputStream(new FileOutputStream("tezt.zip"));//实例化时指定保存路径
zip(out, file, "");
out.close();
print("完成");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void zip(ZipOutputStream out, File file, String filePath) {
try {
if (file.isDirectory()) {
if(filePath.length()>0) {
//putNextEntry的作用就是在压缩包里创建一个目录或者文件
out.putNextEntry(new ZipEntry(filePath+"/"));
}
File subFiles[] = file.listFiles();
for (File f : subFiles) {
zip(out,f,f.getPath());
}
} else {
//putNextEntry的作用就是在压缩包里创建一个目录或者文件
out.putNextEntry(new ZipEntry(filePath));
//得到文件的流并写入到压缩包
FileInputStream in=new FileInputStream(file);
int b;
while ((b=in.read())!=-1) {
out.write(b);
}
in.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}ZipInputStream(解压)使用方法：
思路就是使用压缩包文件得到ZipInputStream和ZipFile实例，ZipInputStream实例获取ZipEntry目录和结构，ZipFile获取内容。
public static void decompressing(String fileFullPath) throws Exception {
File file = new File(fileFullPath);
//ZipInputStream的作用是获取到压缩包里面的目录结构和文件即entry
ZipInputStream in = new ZipInputStream(new FileInputStream(file));
//关键点,zipfile的作用是可以根据得到的entry获取其inputstream的
ZipFile zipFile = new ZipFile(file);
ZipEntry entry = in.getNextEntry();
while ((entry = in.getNextEntry()) != null) {
if (!entry.isDirectory()) {
File sf = new File( entry.getName());
// 创建父级目录(即使是多级也一起创建了)
sf.getParentFile().mkdirs();
//文件输出流，用到保存文件
FileOutputStream fos = new FileOutputStream(sf);
//得到文件内容
InputStream is = zipFile.getInputStream(entry);
int b;
while ((b = is.read()) != -1) {
fos.write(b);
}
is.close();
fos.flush();
fos.close();
}
}
}