（小白学JAVA之）Java高级特性知识点梳理

集合框架和泛型

用数组存储多个同类型的数据，会存在如下一些明显的缺陷：

• 数组长度固定不变，不能很好地适应元素数量动态变化的情况
• 可通过数组名.leng()获取数组的长度，却无法直接获取数组中实际存储的元素个数
• 数组采用在内存中分配连续空间的存储方式存储，根据元素信息查找时效率比较低，需要多次比较

Java集合框架提供了一套性能优良、使用方便的接口和类，它们都位于java.util包中，其主要内容及彼此之间的关系如下图所示：

Java的集合类主要由Map接口和Collection接口派生而来，其中Collection接口有两个常用的子接口，即List接口和Set接口。

List接口

可以存储一组不唯一、无序的对象；List接口常用的实现类有ArrayList和LinkedList

ArrayList

ArrayList类底层为动态数组，遍历元素更快，改变值也就更快；它可以添加任何类型的数据，并且添加的数据都将转换成Object类型

ArrayList类的常用方法

具体实现步骤

1.导入ArrayList类
2.创建ArrayList对象，并添加数据
3.判断集合中是否包含某元素
4.移除索引为0的元素
5.把索引为1的元素替换为其他元素
6.输出某个元素所在的索引位置
7.清空ArrayList集合中的数据
8.判断ArrayList集合中是否包含数据

public static void main(String[] args){
	ArrayList list=new ArrayList(); // 1
	list.add("张三");
	list.add("李四");
	list.add("王五"); // 2
	//判断集合中是否包含"小刘" 3
	System.out.println(list.contains("小刘")); //输出false
	// 4
	list.remove(0);
	// 5
	list.set(1, "黄蓉");
	// 6
	System.out.println(list.indexOf("小龙女")) //没有该元素，输出-1
	// 7
	list.clear();
	// 8
	System.out.println(list.isEmpty()); //第7步已经清空，这里输出true
	//遍历
	for (int i=0; i<list.size(); i++){
		String name = (String)list.get(i);
		System.out.println(name);
	}
	for (Object obj:list){ //增强for
		String name = (String)obj;
		System.out.println(name);
	}
}

LinkedList

LinkedList类底层是双向链表结构，插入和删除更快。它支持实现所有List解耦可选的列表的操作，并允许元素值是任何数据，包括null

LinkedList类的常用方法

LinkedList除了包含ArrayList类所包含的方法外，还提供一些自身特有的方法

具体实现步骤

1.创建LinkedList对象，并添加数据
2.添加头条和末条元素
3.获取头条和末条元素
4.删除头条和末条元素

NewTitle car = new NewTitle(1,"汽车","管理员");
NewTitle medical = new NewTitle(2,"医学","管理员");
NewTitle fun = new NewTitle(3,"娱乐","管理员");
NewTitle gym = new NewTitle(4,"体育","管理员");

// 创建存储新闻标题的集合对象并添加数据
LinkedList newsTitleList = new LinkedList();
newsTitleList.add(car);
newsTitleList.add(medical);

// 2
newsTitleList.addFirst(fun);
newsTitleList.addLast(gym);

// 3
NewTitle first = (NewTitle) newsTitleList.getFirst();
NewTitle last = (NewTitle) newsTitleList.getLast();

// 4
newsTitleList.removeFirst();
newsTitleList.removeLast();

Set接口

Set接口可以存储一组唯一、无序的对象，它常用的实现类有HashSet

HashSet

HashSet集合的特点如下：

• 集合内的元素是无序排列
• HashSet类是非线程安全
• 允许集合元素值为null

HashSet类的常用方法

方法	作用
boolean add(Object o)	如果Set中尚未包含指定元素o，则添加指定元素o
void clear()	从Set中移除所有元素
int size	返回Set中的元素的数量
boolean isEmpty()	如果Set不包含任何元素，则返回true
boolean contains(Object o)	如果Set包含指定元素o，则返回true
boolean remove(Object o)	如果指定元素o存在于Set中，则将其移除

注意！Set接口不存在 get() 方法！

具体实现步骤

1.创建HashSet对象，并添加数据
2.获取新闻标题的总数
3.判断集合中是否包含汽车新闻标题
4.移除对象
5.判断集合是否为空
6.遍历集合

NewTitle car = new NewTitle(1,"汽车","管理员");
NewTitle medical = new NewTitle(2,"医学","管理员");
// 1
Set newsTitleList = new HashSet();
newsTitleList.add(car);
newsTitleList.add(medical);
// 2
newsTitleList.size();
// 3
newsTitleList.contains(car);
// 4
newsTitleList.remove(medical);
// 5
newsTitleList.isEmpty();
// 6
for (Object obj:newsTitleList){
	NewTitle title = (NewTitle) obj;
	System.out.println(title.getTitleName());
}

Iterator接口

Iterator接口表示对集合进行迭代的迭代器。Iterator接口为集合而生，专门实现集合的遍历。此接口主要有如下两个方法：

• hasNext() 判断是否存在下一个可访问的元素，如果有元素可以迭代，则返回true
• next() 返回要访问的下一个元素

使用Iterator接口遍历List类集合：（Set同理）

Iterator it = list.iterator();
while (it.hasNext()){
	System.out.println(it.next());
}

Map接口

Map接口存储一组成对的键（key）— 值（value）对象，提供key到value的映射，通过key来检索。Map接口中的key不要求有序，不允许重复。value同样不要求有序，但允许重复。

Map接口的常用用法

HashMap实现步骤

最常用的Map实现类是HashMap，其优点是查询指定元素效率高。

1.导入HashMap类
2.创建HashMap对象
3.调用HashMap对象的put()方法，向集合中添加数据
4.输出学员个数
5.输出键集
6.判断是否存在“Jack”这个键，如果存在，则根据键获取相应的值

// 1
Student student1 = new Student("李明","男");
Student student2 = new Student("刘丽","女");
// 2
Map students = new HashMap();
// 3
students.put("Jack", student1);
students.put("Rose", student2);
// 4
students.size();
// 5
students.keySet();
// 6
String key = "Jack";
if (students.containsKey(key)) {
	Student student = (Student) students.get(key);
	System.out.println("英文名为"+key+"的学员姓名："+student.getName());
}

遍历HashMap集合

1.遍历：使用entrySet方法获取键值对的集合

Set set = students.entrySet();
Iterator itr = set.iterator();
while (itr.hasNext()){
	System.out.println(itr.next());
}

2.遍历键集：键集用Set存储

for (Object key:students.keySet()) {
	System.out.println(key.toString());
}

3.遍历值集：值集用Collection存储

Collection values = map.values();
for (Object value : values) {
	System.out.println(value);
}

Collections类

Collections类是Java提供的一个集合操作工具类，它包含了大量的静态方法，用于实现对集合元素的排序、查找和替换等操作。

注意！Collections和Collection是不同的，前者是集合的操作类，后者是集合接口。

Collections类常用方法

以下方法皆为静态方法：
sort() 排序
binarySearch() 查找
max()\min() 查找最大\最小值

Comparable接口

通过重写compareTo()方法，用来实现比较大小
定义语句：int compareTo(Object obj);
参数：obj即将要比较的对象
返回值：负整数、零或正整数，根据此对象是小于、等于还是大雨指定对象返回不同的值

实例：

public int compareTo(Object obj) {
	Student student = (Student) obj;
	//如果学号相同，那么两者就是相等的
	if (this.number==student.getNumber){
		return 0;
	//如果这个学生的学号大于传入学生的学号
	} else if (this.number>student.getNumber()){
		return 1;
	//如果这个学生的学号小于传入学生的学号
	} else {
		return -1;
	}
}

元素之间可以比较大小之后，就可以使用Collections类的sort()方法对元素进行排序操作了。Map接口本身是无序的，所以不能进行排序。可以对List接口进行排序，但注意必须是实现了Comparable接口的元素才可以。

ArrayList list = new ArrayList();
list.add(student1);
list.add(student2);
list.add(student3);
//sort()方法排序
Collections.sort(list);
//binarySearch()方法查找
int index = Collections.binarySearch(list, students3);

替换集合元素

如果需要把一个List集合中的所有元素都替换为相同的元素，则可以使用Collections类的静态方法fill()来实现

Collections.fill(list, "李明");

泛型

泛型的本质是参数化类型。Java语言引入泛型的好处是安全简单，且所有强制转换都是自动和隐式进行的，提高了代码的重用率

泛型的定义

语法格式：类1或者接口<类型实参>对象=new 类2<类型实参>();
例如：ArrayList<String> list = new ArrayList<String>();
上述代码表示创建了一个ArrayList集合，但规定该集合中存储的元素类型必须为String类型

泛型在集合中的应用

学习List接口时提到add()方法的参数是Object类型，无论什么对象放入List接口，或其子接口，或实现类，都会被转换为Object类型。在通过get()方法取出集合中的元素是必须进强制类型转换，不仅繁琐且容易出现异常。

引入泛型是如何解决上述问题的呢？ 使用泛型集合在创建集合对象时指定了集合中元素的类型，从集合中取出元素时，无需进行强制类型转换，并且如果把非指定类型对象放入集合，会出现编译错误。

List和ArrayList的泛型形式是List<E> ArrayList<E>
Map和HashMap的泛型形式是Map<K,V> HashMap<K,V>

实用类

Java应用程序编程接口是运行库的集合，预定义了一些接口和类，程序员可以直接使用这些已经被打包的接口和类来开发具体的应用。

常用的包：
java.lang: 编写Java程序时最广泛使用的包，自动导入到所有的程序中，包含了Java程序的基础类和接口
java.util: 包含了系统辅助类，特别是Collection、List和Map等集合类
java.io: 包含了与输入\输出有关的类
java.sql: 包含了与数据库相关的类

枚举

枚举是指有一组固定的常量组成的类型，使用关键字enum定义

[Modifier] enum enumName {
	enumContantName1, enumConstantName2... // 表示枚举常量列表，枚举常量之间以逗号隔开
	[field, method] //表示其他的成员，包括构造方法，置于枚举常量的后面
}
//在枚举中，如果除了定义枚举常量，还定义了其他成员，则枚举常量列表必须以分号(;)结尾

实例：

public enum Week{
	MON, TUE, WED, THU, FRI, SAT, SUN
}
public void doWhat(Week day){
	switch(day){
		case MON:
		case TUE:
		case WED:
		case THU:
		case FRI:
			System.out.println("工作日");
			break;
		case SAT:
		case SUN:
			System.out.println("周末");
			break;
	}
}

包装类

Java语言是面向对象的，但是基本数据类型不是面向对象的。包装类的用途主要有两个：

• 包装类作为和基本数据类型对应的类存在，方便对象操作
• 包装类包含每种基本数据类型的相关属性，如最大最小值，以及祥光的操作方法

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
cahr	Character
int	Integer
long	Long
float	Float
double	Double

拆箱和装箱

装箱：把基本数据类型变为包装类型
拆箱：把包装类型转为基本数据类型

赋值方式

以Integer为例：几种赋值方法

• new Integer(整形)
• new Integer(字符串)
• Interger.valueOf(字符串/整形)
• Integer.paraseInt(字符串)

注意：Character类的valueOf()方法只有一个版本的定义，即valueOf(char c)，它返回一个表示指定char值的Character对象

Math类

java.lang.Math类提供了常用的数学运算方法和两个静态常量E（自然对数的底数） 和PI（圆周率）
这个类是final类，因此没有子类，Math类常见方法：

• static double abs(double a) 返回一个绝对值
• static double max(double a, double b) 返回其中一个较大的值
• static double random() 返回一个随机值

Random类

Random类用于生成随机数

构造方法	说明
Random()	创建一个新的随机数生成器
Random(long seed)	使用单个long种子创建一个新的随机数生成器

用同一个种子值来初始化两个Random 对象，然后用每个对象调用相同的方法，得到的随机数也是相同的

比较常用的是nextInt()方法，它返回下一个伪随机整型数

int nextInt();
int nextInt(int n); //从0到n之间（不包括n）

日期操作类

Date类 对象用来表示日期和时间，该类提供了一系列操作日期和时间各组成部分的方法

Calendar类 也是用来操作日期和时间的类，它是抽象类，可以通过静态方法getInstance()获得Calender类的对象。它的方法如下：

方法	说明
int get(int field)	返回给定日历字段的值
YEAR	指示年
MONTH	指示月
DAY_OF_MONTH	指示一个月中的某天
DAY_OF_WEEK	指示一个星期中的某天

DateFormat类 是一个抽象类，提供了多种格式化和解析时间的方法。使用比较多的是它的子类SimpleDateFormat

Date date = new Date();
SimpleDateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("当前时间为"+formater.format(date));

String类

String类的常用方法

1.求字符串长度 str.length()

2.字符串比较 字符串1.equals(字符串2)
需要注意的是：“==”比较的是两个字符串对象在内存中的地址，而equals()比较的是两个字符串对象的值
忽略大小的字符串比较字符串1.equalsIgnoreCase(字符串2)
转大小写 toLowerCase() / toUpperCase()

3.字符串拼接 字符串1.concat(字符串2)

4.字符串提取和查询

5.字符串拆分 字符串名.split(separator, limit);
separator和limit均为可选项

StringBuffer和StringBuilder类

1.toString()方法
2.append()方法
3.inset()方法 字符串.insert(位置，参数)
4.replace()方法字符串名.replace(int start,int end,String str)

三者比较

• String：不可被改变，真正意义上的安全，在频繁字符串拼接的情况下，速度非常慢
• StringBuffer：线程安全，速度慢
• StringBuilder：线程不安全，速度快

I/O

java.io包提供了一些接口和类，对文件进行基本的操作，包括对文件和目录属性的操作、对文件读写的操作等

File类访问文件属性

File类的常用方法

流

流是指一连串流动的字符，是以先进先出的方式发送和接受数据的通道

流的分类

InputStream

方法	说明
int read()	从输入流中读取下一个字节数据
int read(byte[] b)	从输入流中读取数据，并将数据存储在缓冲区数组b中，返回实际读取的字节数
int read(byte[] b, int off, int len)	从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始
void close()	关闭输入流

InputStream类的常用子类有FileInputStream，用于从文件中读取数据

FileInputStream读文件的流程：
1、FileInputStream对象和String对象声明
2、创建FileInputStream对象（文件路径或File对象）
3、读单字节或整个读到byte数组中
4、转成字符串
5、关闭FileInputStream流
6、返回结果字符串

public static String readFile(String path){
	FileInputStream fis = null;
    String str = null;
    try {
        fis = new FileInputStream(path);
        byte[] b = new byte[fis.available()];
        fis.read(b);
        str = new String(b);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return str;
}

OutputStream

方法	说明
void write(int c)	将制定的字节数据写入此输出流中
void write(byte[] buf)	将数组buf中的所有字节写入此输出流中
void write(byte[] b, int off, int len)	将字节数组中从偏移量off开始的长度为len的字节数据输出到输出流中
void close()	关闭输出流

OutputStream类的常用子类为FileOutputStream，用于向文件写数据

FileOutputStream写文件的流程：
1、File对象装载文件路径
2、判断文件父级目录是否存在，不存在则创建
3、声明FileOutputStream对象
4、创建FileOutputStream对象（file对象，是否追加）
5、把要写的字符串转成byte数组，并写入输出流
6、关闭FileOutputStream流

public static void writeFile(String str, String path, boolean isAppend){
	File f =new File(path);
    if (!f.getParentFile().exists()){
        f.getParentFile().mkdirs();
    }
    FileOutputStream fos = null;
    try {
        fos = new FileOutputStream(f, isAppend);
        byte[] b = str.getBytes();
        fos.write(b);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Reader

方法	说明
int read()	从输入流中读取单个字符，返回所读取的字符数据
int read(byte[] c)	从输入流中最多读取c.length个字符
int read(char[] c, int off, int len)	从输入流中读取最多len个字符
void close()	关闭流

Reader类的常用子类为BufferedReader，接受Reader对象作为参数，并对其添加字符缓冲器

使用BufferedReader类和FileReader类读取文本文件数据：

public static String readBuffer(String path){
    File f = new File(path);
    FileReader fr = null;
    BufferedReader br = null;
    String str = null;
    try {
        fr = new FileReader(f);
        br = new BufferedReader(fr);
        String s;
        StringBuffer sb = new StringBuffer();
        while ((s=br.readLine())!=null){
            sb.append(s);
        }
        str = sb.toString();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return str;
}

Writer

方法	说明
void write(String str)	将str字符串里包含的字符输出到指定的输出流中
void write(String str, int off, int len)	将str字符串里从off位置开始，长度为len的多个字符输出到输出流中
void close()	关闭输出流
void flush()	刷新输出流

Writer类的常用子类为BufferedWriter，用于将数据缓冲到字符输出流

使用BufferedWriter以及FileWirter对象向文本文件中写数据

public static void writeBuffer(String str, String path, boolean isAppend){
	FileWriter fw = null;
	BufferedWriter bw = null;
	try {
		fw = new FileWriter(path, isAppend);
		bw = new BufferedWriter(fw);
		bw.write(str);
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		try {
			bw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			fw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

注意！ 在操作上字节流与字符流有一个区别，字符流在操作时使用了缓冲区（内部存储器），而字节流在操作时直接操作文件，不会使用缓冲区；所有的这些方法在出现错误时都会抛出IOException异常。

读写二进制文件

读写二进制文件（例如图片）文件常用的类有DataInputStream和DataOutputStream

实例：

public static void copyData(String fromPath, String targetPath){
    FileInputStream fis = null;
    DataInputStream dis = null;
    FileOutputStream fos = null;
    DataOutputStream dos = null;
    try {
        fis = new FileInputStream(fromPath);
        dis = new DataInputStream(fis);
        fos = new FileOutputStream(targetPath);
        dos = new DataOutputStream(fos);
        int tmp;
        while ((tmp=dis.read())!=-1){
            dos.write(tmp);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            dos.close();
            fos.close();
            dis.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对象流

序列化和反序列化：

• 场景一：内存对象需要在其它环境下使用
  两个进程间进行网络通信时，无论是发送何种类型的数据，均需以二进制序列形式进行传送
  发送方必须将数据对象（比如Java对象）转化为字节序列
  接收方则需要将接收到的字节序列再还原成Java对象
• 场景二：内存对象需要在将来某个时间使用
  将内存中的数据对象永久存储在磁盘中（持久化）

常用序列化方案：

序列化保存对象信息

步骤可以概括成如下两大步：
1.创建一个对象输出流（ObjectOutputStream），它可以包装一个其他类型的输出流，如文件输出流FileOutputStream
2.通过对象输出流的writeObject（）方法写对象，也就是输出可序列化对象

实例：使用序列化将学生对象保存到文件中
1.引入相关类
2.创建学生类，实现Serializable接口
3.创建对象输出流
4.调用writeObject()方法将对象写入文件
5.关闭对象输出流

public class Student implements Serializable{
	//Student属性和方法
}

public class TestStudent{
	public static void main(String[] args){
		ObjectOutputStream oos = null;
		try{
			//创建ObjectOutputStream输出流
			oos=new ObjectOutputStream(new FileOutputStream("目标文件路径"));
			Student stu = new Student("李梅", 22, "女");
			//对象序列化，写入输出流
			oos.writeObject(stu);
		} catch(IOException e) {
			e.printStackTrace();
		} finally {
			if (oos!=null) {
				try {
					oos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

//oos还可以写入集合中的对象
ArrayList<Student> list = new ArrayList<Student>();
list.add(stu);
list.add(stu1);
oos.writeObject(list);

反序列化获取对象信息

反序列化的步骤大致概括为以下两步：
1.创建一个对象输入流（ObjectInputStream），它可以包装一个其他类型的输入流，如文件输入流FileInputStream
2.通过对象输入流的readObject()方法读取对象，该方法返回一个Object类型的对象，如果程序知道该Java对象的类型，则可以将该对象强制转换成其真实的类型。

实例：使用反序列化读取文件中的学生对象
1.引入相关类
2.创建对象输入流
3.调用readObject()方法读取对象
4.关闭对象输入流

ObjectInputStream ois - null;
trry {
	ois = new ObjectInputStream(new FileInputStream("读取文件路径"));
	Student stu = (Student) ois.readObject();
	//输出生成后的对象信息
	System.out.println("姓名为"+stu.getName());
	...
} catach (IOException e) {
	e.printStackTrace();
} finally {
	if (ois!=null) {
		try {
			ois.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

//集合的反序列化
ArrayList<Student> List = (ArrayList<Student>) ois.readObject();
Student stu = (Student) ois.readObject();
for (Student stu:list) {
	System.out.println("姓名为"+stu.getName());
}

反射

Java的反射机制是Java特性之一；Java反射机制是指在运行状态中，动态获取信息以及动态调用对象方法的功能

反射的作用：

• 在运行时获取类的修饰符，包名，类名，实现的接口，继承的父类
• 在运行时获取类的所有属性名，修饰符，属性类型
• 在运行时获取所有方法，方法的返回值类型，方法名，方法参数数量，方法参数类型
• 在运行时调用加载类的方法

访问类包含的构造

public class TestConstructor {
    public static void main(String[] args) throws Exception{
        Class<Student> c = Student.class;
        Constructor<Student> sClass = c.getDeclaredConstructor(int.class, String.class, String.class);
        sClass.setAccessible(true);
        Student s = sClass.newInstance(2, "baba", "male");
        System.out.println(s);
    }
}

访问类包含的方法

public class TestMethod {
    public static void main(String[] args) throws Exception {
        Student s = TestStudent123.getStudent();
        Class<Student> c = Student.class;
        Method setStuId = c.getDeclaredMethod("setStuId", int.class);
        setStuId.setAccessible(true);
        
        setStuId.invoke(s, 3);
        Method getStuId = c.getDeclaredMethod("getStuId");
        getStuId.setAccessible(true);
        Object stuId = getStuId.invoke(s);
        
        System.out.println(s);
        System.out.println(stuId);
    }
}

访问类包含的属性

public class TestField {
    public static void main(String[] args) throws Exception{
        Student student = TestStudent123.getStudent();
        Class<Student> c = Student.class;
        Field stuId = c.getField("stuId");
        stuId.set(student, 11);
        Field stuName = c.getDeclaredField("stuName");
        stuName.setAccessible(true);
        stuName.set(student, "张三");
        
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            System.out.println(field.get(student));
        }
        System.out.println(student);
    }
}

多线程

进程

进程是程序的一次动态执行过程，它有如下特点：

• 进程是系统运行程序的基本单位
• 每一个进程都有自己独立的一块内存空间、一组系统资源
• 每一个进程的内部数据和状态都是完全独立的

线程

线程是进程中执行运算的最小单位，一个进程在其执行过程中可以产生多个线程，而线程必须在某个进程内执行
线程和进程既有联系又有区别：

• 一个进程中至少要有一个线程
• 资源分配给进程，同一进程的所有线程共享该进程的所有资源
• 处理机分配给线程，即真正在处理机上运行的是线程

多线程的优势

多线程程序可以带来更好的用户体验，避免因程序执行过慢而导致出现计算机死机或者白屏的情况
多线程程序可以最大限度地提高计算机系统的利用效率

编写线程类

使用一个线程的过程可以分为如下4个步骤：

使用Thread类

定义MyThread类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class MyThread extends Thread{
	private int count=0;
	//重写run方法
	public void run(){
		while(count<100){
			count++;
			System.out.println(count)
		}
	}
}
publict class Test{
	public static void main(String[] args){
		MyThread mt = new MyThread();
		mt.start();
	}
}

使用Runnable接口

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

public class MyThread implements Runnable{
	private int count = 0;
	public void run(){
		while(count<100){
			count++;
		}
	}
}
public class Test{
	public static void main(Stirng[] args){
		Thread thread = new Thread(new MyThread());
		thread.start();
	}
}

比较两种创建线程的方式

• 继承Thread类：
  编写简单，可直接操作线程
  适用于单继承
• 实现Runnable接口：
  避免单继承局限性
  便于共享资源

线程的状态

线程调度

实现线程调度的方法：

• join()方法

for(int i=0;i<10;i++){
	if(i==5){
		MyThread mt = new MyThread('MyThread');
		try{
			mt.start();
			mt.join();
		} catch...
	}
}

• sleep方法

try{
	Thread.sleep(100) //睡眠100毫秒
} catch...

• yield方法

for(int i=0;i<5;i++){
	System.out.println(Thread.currentThread().getName()+"正在运行："+i);
	if(i==3){
		System.out.print("线程礼让：");
		Thread.yield();	
	}
}

线程同步

多个线程操作同一共享资源时，将引发数据不安全问题

实现线程同步

1.同步方法
通过在方法声明中加入synchronized关键字来声明同步方法

访问修饰符 synchronized 返回类型 方法名{}
//或者
synchronized 访问修饰符 返回类型 方法名{}

2.同步代码块
同步代码块的语法格式如下：

synchronized(synObjcet){ //通常填写this
	//需要同步访问控制的代码
}

线程通信

Java提供了如下三个方法实现线程之间的通信：

• wait()：调用wait()方法会挂起当前线程，并释放共享资源的锁
• notify()：调用任意对象的notify()方法会在因调用该对象的wait()方法而阻塞的线程中随机选择一个线程解除阻塞，但要等到获得锁之后才可以真正执行
• notifyall()：调用了notifyall()方法会将因调用该对象的wait()方法而阻塞的所有线程一次性全部解除阻塞

注意： 这三个方法被所有的类继承并且不允许重写，只能在同步方法或同步代码块中使用。

XML

XML简介

• XML（EXtensible Markup Language）,可扩展标记语言
• 特点：
  XML与操作系统、编程语言的开发平台无关
  实现不同系统之间的数据交换
• 作用：
  数据交互
  配置应用程序和网站
  Ajax基石

XML文本结构

<?xml version="1.0" encoding="UTF-8"?>
<books>
    <!--图书信息 -->
    <book id="bk101">
        <author>王珊</author>
        <title>.NET高级编程</title>
        <description>包含C#框架和网络编程等</description>
    </book>
    <book id="bk102">
        <author>李明明</author>
        <title>XML基础编程</title>
        <description>包含XML基础概念和基本作用</description>
    </book>
</books>

XML声明

<?xml version="1.0" encoding="UTF-8"?>

XML声明由以下几个部分组成：
version：文档符合XML1.0规范
encoding：文档字符编码，默认为“UTF-8”

XML标签

在XML中用<>括起来的各种标签来标记数据，如<author></author>

根元素

每个XML文档必须有且仅有一个根元素，如<book></book>
根元素的特点如下：
根元素是一个完全包括文档中其他所有元素的元素
根元素的起始标签要放在所有其他元素的起始标签之前
根元素的结束标签要放在所有其他元素的结束标签之后

元素与属性

XML文档内容由一系列标签元素组成

<元素名 属性名=“属性值”>元素内容</元素名>

编写注意事项

• 所有XML元素都必须有结束标签
• XML标签对大小写敏感
• XML必须正确的嵌套
• 同级标签以缩进对齐
• 元素名称可以包含字母、数字或其他的字符
• 元素名称不能以数字或者标点符号开始
• 元素名称中不能含空格

注意！！
属性值用双引号包裹
一个元素可以有多个属性
属性值中不能直接包含<、“、&
不建议使用的字符：‘、>

命名空间

命名空间的必要性： XML解析器在解析XML文档时，对于重名元素，可能会出现解析冲突。命名空间有助于标准化元素和属性，并为它们加上唯一的标识

声明命名空间：

xmlns:[prefix]="[命名空间的URL]"

属性和命名空间： 除非带有前缀，否则属性属于它们的元素所在的命名空间

实例应用

<?xml version="1.0" encoding="UTF-8"?>
<cameras xmlns:canon="http://www.canon"
    xmlns:nikon="http://www.nikon.com">
    <canon:camera prodID="P663" name="Camera傻瓜相机"/>
    <nikon:camera prodID=“K29B3” name=“Camera超级35毫米相机"/>
</cameras>

解析XML技术

• DOM
  基于XML文档树结构的解析
  适用于多次访问的XML文档
  特点：比较消耗资源
• SAX
  基于事件的解析
  适用于大数据量的XML文档
  特点：占用资源少，内存消耗小
• DOM4J
  非常优秀的Java XML API
  性能优异、功能强大
  开放源代码

这里着重讲述使用DOM读取XML数据

DOM

DOM介绍：文档对象模型(Document Object Model)
DOM把XML文档映射成一个倒挂的树

访问DOM树节点

public class TestXML {
    Document document;
    public void setDocument(String xmlPath){
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder=factory.newDocumentBuilder();
            document=builder.parse(xmlPath);
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception{
        TestXML xml = new TestXML();
        xml.setDocument("D:\\KB09\\JAVA\\2020.8.7\\src\\Demo\\phone_info.xml");
        NodeList brands = xml.document.getElementsByTagName("brand");
        Node item = brands.item(0);

        Element e = (Element) item;
        System.out.println(e.getAttribute("name"));
//        for (int i = 0; i < brands.getLength(); i++) {
//            Node n = brands.item(i);
//            if (n instanceof Element){
//                Element e = (Element) n;
//                System.out.println(e.getAttribute("name"));
//            }
//        }
        NodeList hwTypes = e.getChildNodes();
        Node root = xml.document.getElementsByTagName("phoneInfo").item(0);
        Element sx = xml.document.createElement("brand");
        sx.setAttribute("name","三星");
        Element sxType = xml.document.createElement("type");
        sxType.setAttribute("name", "note20");
        sx.appendChild(sxType);
        root.appendChild(sx);


        //保存更改
        TransformerFactory tf = TransformerFactory.newInstance();
        tf.setAttribute("indent-number", 4);
        Transformer t = tf.newTransformer();
        t.setOutputProperty(OutputKeys.INDENT,"yes");
        t.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
        DOMSource source = new DOMSource(xml.document);
        FileOutputStream fos = new FileOutputStream("D:\\KB09\\JAVA\\2020.8.7\\src\\Demo\\phone_info.xml");
        StreamResult sr = new StreamResult(new OutputStreamWriter(fos));
        t.transform(source, sr);

//        for (int i = 0; i < hwTypes.getLength(); i++) {
//            Node n = hwTypes.item(i);
//            if (n instanceof Element){
//                Element type = (Element) n;
//                Node firstChild = type.getFirstChild();
//                if (firstChild instanceof Text){
//                    Text t=(Text) firstChild;
//                    System.out.println(t.getWholeText().trim());
//                }
//            }
//        }
//
//        Node item2 =brands.item(1);
//        Element e2 = (Element) item2;
//        System.out.println(e2.getAttribute("name"));
//        NodeList appleTypes = e2.getChildNodes();
//        for (int i = 0; i < appleTypes.getLength(); i++) {
//            Node n = appleTypes.item(i);
//            if (n instanceof Element){
//                Element type = (Element) n;
//                Node firstChild = type.getFirstChild();
//                if (firstChild instanceof Text){
//                    Text t=(Text) firstChild;
//                    System.out.println(t.getWholeText().trim());
//                }
//            }
//        }


//        for (int i = 0; i < brands.getLength(); i++) {
//            Node item = brands.item(i);
//            Element e = (Element) item;
//            System.out.println(e.getAttribute("name"));
//            NodeList Types = e.getChildNodes();
//            for (int j = 0; j < Types.getLength(); j++) {
//                Node node = Types.item(j);
//                if (node instanceof Element){
//                    Element type = (Element) node;
//                    Node firstChild = type.getFirstChild();
//                    if (firstChild instanceof Text){
//                        Text t = (Text) firstChild;
//                        System.out.println(t.getWholeText().trim());
//                    }
//                }
//            }
//            System.out.println();
//        }

    }
}

JSON

JSON简介

• JSON（JavaScript Object Notation）是JavaScript中的对象表示法
• 轻量级的文本数据交换格式，独立于JavaScript语言
• 具有自我描述性
• 比XML传输速度快

JSON语法规则

• 数据由名称/值对构成
• 数据之间由逗号分隔
• 大括号内为对象
• 中括号内为数组

Java对象转为JSON字符串

使用FastJason（下载地址：FastJason）

class Student{
    private String name="";
    private int age;
    private List<String> skills;

    public Student(String name, int age, List<String> skills) {
        this.name = name;
        this.age = age;
        this.skills = skills;
    }
......//省略getter和setter
}

Student stu=new Student("Jason",20, Arrays.asList("Java", "Hadoop", "Python"));
String stuJson=com.alibaba.fastjson.JSON.toJSON(stu).toString();
System.out.println(stuJson);

JSON字符串转为Java对象

String json="{\"skills\":[\"Java\",\"Hadoop\",\"Python\"],
			\"name\":\"Jason\",
			\"age\":20
			}";
Student stuNew = com.alibaba.fastjson.JSON.parseObject(json,Student.class);
System.out.println(stuNew.getName());

正则表达式

正则表达式简介：

• 正则表达式描述了一种字符串匹配的模式，也称规则表达式
• 常用于检索、替换符合指定模式（规则）的文本
• 大多数语言都支持正则表达式

正则表达式语法

• 正则表达式是由普通字符与特殊字符组成的字符串

• 普通字符
  原义字符、非打印字符

• 特殊字符
  元字符：* + ? $ ^ . | \ ( ) { } [ ]
  

• 非打印字符
  

• 预定义字符
  

JAVA正则表达式

java.util.regex包
Pattern类：表示一个正则表达式，或者说匹配模式
Matcher类：Pattern对象matcher()方法的返回值，表示正则表达式对输入字符串的匹配结果

分组

如何获取字符串“hello”中的字符“e”？

Pattern p=Pattern.compile("h(\\w*)llo");
Matcher matcher=p.matcher("hello");
if(matcher.matches())
	System.out.println(matcher.group(1));//输出匹配结果

命名分组

如何获取字符串“hello”中的字符“e”？

Pattern p=Pattern.compile("h(?<result>\\w*)llo");
Matcher matcher=p.matcher("hello");
if(matcher.matches())
	System.out.println(matcher.group("result"));//输出匹配结果