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