• 2.JAVA 语言基础部分（java的语言基础）
• ### Error querying database. Cause: java.lang.IllegalArgumentException: invalid comparison: cn.xiaojian.blog.po.BlogType and java.lang.String ### Cause: java.lang.IllegalArgumentException: ...
• 'java.lang.NoClassDefFoundError 由 java.lang.ClassNotFoundException 引起的 Ljava/util/Base64 解析失败 未找到类“java.util.Base64”
• (Java 学习笔记) Java Threading (Java 线程)
• Android 应用程序开发支持哪些 Java 版本我可以使用 1.8 以上的 java 版本还是 java 8

2.JAVA 语言基础部分（java的语言基础）

1. 语言基础

二进制操作 

“&” 按位与：a 与 b 同时为 1 结果为 1，否则为 0；

“|” 按位或：a 与 b 其中任一个为 1，否则为 0

“~” 按位取反

“^” 按位与或：a 与 b 值相同 (同为 0 或 1) 时为 0，否则为 1

“<<” 左移：右边以 0 来补充

“>>” 右移：左边第 1 位相同值来补全，右边抛弃

“>>>” 无符号右移：左边高位以固定值 0 补全

技巧：一个数左移 n 位，结果为这个数乘以 2ⁿ ; 一个数右移 n 位，结果为这个数除以 2ⁿ

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 ();// 是否为目录

文件输入 / 输出流

FileInputStream\FileOutputStream 是字节流；FileReader\FileWriter 是字符流；有中文字符更适合使用后者。

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(); 
			} 
		}
	}

### Error querying database. Cause: java.lang.IllegalArgumentException: invalid comparison: cn.xiaojian.blog.po.BlogType and java.lang.String ### Cause: java.lang.IllegalArgumentException: ...

'java.lang.NoClassDefFoundError 由 java.lang.ClassNotFoundException 引起的 Ljava/util/Base64 解析失败 未找到类“java.util.Base64”

compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
}