6月
知识
1.Lambda表达式：
Lambda表达式是从java8开始引入的一个新特性。
把代码作为参数传递。
lambda引入了->操作符，
方法的参数列表 -> 需要实现的代码
为什么要用Lambda
使用lambda表达式要求这个接口中只能有一个抽象方法，这种接口叫函数式接口。
Stream流
// 流的创建，用来传输数据的。自己不存储数据
Stream<String> strStream = Stream.of("aa", "bb", "cc", "dd");
// 使用集合创建流
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
Stream<String> strStream2 = list.stream();
// 创建无限流
Supplier<Integer> s = () -> {
Random ran = new Random();
return ran.nextInt(50000);
};
Stream<Integer> intStream = Stream.generate(s);
}
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
Stream<String> strStream = list.stream();// 只能用一次
// 查看Stream中的元素数量
// System.out.println(strStream.count());
// 遍历Stream中的元素
// strStream.forEach(()->{});
Optional<String> optional = strStream.findFirst();// 取出第一个元素
String frist = optional.get();
System.out.println(frist);
System.out.println(list);
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
Stream<String> stream = list.stream();
// 获取一个排序的流
String s = list.stream().sorted((s1, s2) -> s2.compareTo(s1)).findFirst().get();
stream.sorted().forEach((st) -> {
System.out.print(st);
if (!s.equals(st)) {
System.out.print("-");
}
});
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
Stream<String> stream = list.stream();
// 获取一个排序的流
String s = list.stream().sorted((s1, s2) -> s2.compareTo(s1)).findFirst().get();
stream.sorted().forEach((st) -> {
System.out.print(st);
if (!s.equals(st)) {
System.out.print("-");
}
});
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
Stream<String> stream = list.stream();
// 获取一个排序的流
String s = list.stream().sorted((s1, s2) -> s2.compareTo(s1)).findFirst().get();
stream.sorted().forEach((st) -> {
System.out.print(st);
if (!s.equals(st)) {
System.out.print("-");
}
});
List<Person> persons = new ArrayList<>();
List<String> infos = new ArrayList<>();
infos.add("1-qq-12");
infos.add("2-qdq-52");
infos.add("3-qqvfddv-12");
infos.add("4-qqv-22");
// 把流中的所有字符转为person对象
infos.stream().map((info) -> {
String[] i = info.split("-");
return new Person(i[0], i[1], i[2]);
}).forEach((p) -> persons.add(p));
System.out.println(persons);
IO流
File类
File file = new File("E:\\QQPCmgr\\Desktop\\新建文本文档.txt");
// 文件是否存在
System.out.println(file.exists());
// file对象的文件能否执行
System.out.println(file.canExecute());
// 如果没有创建文件
if (!file.exists()) {
file.createNewFile();
}
// // 如果有删除文件
// if(file.exists()) {
//
// file.delete();
// }
// 获取file对象指向的文件的全路径
System.out.println(file.getAbsolutePath());
// 获取文件名
System.out.println(file.getName());
// 获取上级目录对应的file对象
File p = file.getParentFile();
System.out.println(p);
System.out.println(file.getPath());
// 判断file对象是否指向的是一个文件夹
System.out.println(file.isDirectory());
// 判断file对象是否指向的是一个文件
System.out.println(file.isFile());
// 判断是否隐藏文件
System.out.println(file.isHidden());
// 查看文件最后的修改时间
System.out.println(file.lastModified());
// 获取文件的长度
System.out.println(file.length());
// 获取file指向的文件夹所有的文件和文件夹
System.out.println("=======");
File[] files = file.listFiles();
// for(File f:files) {
// System.out.println(f);
// }
//
// 创建文件夹，如果父文件夹不存在，也创建
file.mkdirs();
// renameTo是一个剪切并重命名的效果00
File f1 = new File("E:\\\\QQPCmgr\\\\Desktop\\新建.txt");
file.renameTo(f1);
IO：
IO:input output 相对程序而言:把数据读到程序中来是输入，把程序中的数据写出去是输出 Reader是一个输入流
输入流：
public void testReader() {
Reader r = null;
try {
// 创建了一个输入流
r = new FileReader("");
char[] c = new char[2];
StringBuilder sb = new StringBuilder();
while (true) {
// read方法用于读取文件内容，返回值是读取的长度，读取的内容存到传入数组中。
int len = r.read(c);
if (len == -1) {
break;
}
// 创建字符串时只需要读取的长度个
String s = new String(c, 0, len);
sb.append(s);
}
System.out.println(sb.toString());
} catch (Exception e) {
// e.printStackTrace();
} finally {
try {
r.close();
} catch (Exception e) {
// e.printStackTrace();
}
}
}
输出流：
public void testWriter() {
String src = "我很帅但我很温柔。";
Writer w = null;
try {
// 创建一个输出流対象
w = new FileWriter("E:\\QQPCmgr\\Desktop\\新建.txt");// 写出内容
w.write(src);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
w.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
利用输入输出流来复制文件：
public void testCopy1() {
Reader r = null;
Writer w = null;
try {
r = new FileReader("");
w = new FileWriter("");
char[] c = new char[2];
int len;
while ((len = r.read(c)) != -1) {
w.write(c, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
w.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
r.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
二进制文件：
public void testCopy2() throws Exception {
/**
* 事计算机中的文件分成两大类 一类是文本文件:用记事本，editplus
* ultroedit-类的文本编辑器打开，并且可以看懂内容的文件。*一类是二进制文件:除了上面的就是二进制文件。
*/
InputStream is = new FileInputStream(" ");
OutputStream os = new FileOutputStream(" ");
byte[] b = new byte[1024];
int len;
while ((len = is.read(b)) != -1) {
os.write(b, 0, len);
}
os.close();
is.close();
}
}
基于TCP的套接字编程：
客户端：
public void datagramSocket() {
try {
//客户端
DatagramSocket ds=new DatagramSocket(7777);
//要发送的数据
byte[]b ="我就是小可耐".getBytes();
try {
DatagramPacket dp=new DatagramPacket(b, b.length,InetAddress.getByName("120.0.0.1"),8888);
try {
ds.send(dp);
byte []b2=new byte[1024*1024];
DatagramPacket dp2=new DatagramPacket(b2, b2.length);
ds.receive(dp2);
System.out.println(new String(b2,0,dp2.getLength()));
} catch (IOException e) {
e.printStackTrace();
}
} catch (UnknownHostException e) {
e.printStackTrace();
}
} catch (SocketException e) {
e.printStackTrace();
}
}
服务端：
public void datagramSocketServer() {
try {
//服务端DatagramSocket，指定一个端口
DatagramSocket ds= new DatagramSocket(8888);
//用于储存接收的数据
byte[] b=new byte[1024*1024];
//数据包
DatagramPacket dp=new DatagramPacket(b, b.length);
//接收
try {
ds.receive(dp);
//获取数据长度
int len=dp.getLength();
System.out.println(new String(b,0,len));
String resp="嗯哼，是的是的。";
//通过数据包取出地址
InetAddress client=dp.getAddress();
ds.send(new DatagramPacket(resp.getBytes(), resp.getBytes().length));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
反射
反射是框架设计的灵魂
（使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码））
一、反射的概述
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.
以上的总结就是什么是反射
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。
5.多线程
Thread
程序：可以运行的一波代码。
进程：程序的一次运行
线程：线程可以理解成轻量级进程。
一个进程一定会有一个主线程，主线程可能以有多个子线程。这样就构成了多线程。
线程之间如何工作：
线程和线程之间是采用抢占硬件资源的方式来运行。
多线程会提高效率吗？不一定
线程的生命周期：
新建
就绪
运行
阻塞
死亡
线程的创建：
一，继承Thread类的方式
1.写一个类继承Thread类
2.重写run方法
3.在主线程中创建该类的对象
4.调用该对象的start方法。
二，实现Runnable接口
1.写一个类实现Runnable接口
2.重写run方法
3.在主线程中创建一个1类的对象
4.创建一个Thread对象，把3中的对象传入。
5.调用4对象的start方法。
6.数据库一
什么是数据库？Database
数据库就是用于存储数据的仓库。
数据库程序分服务端和客户端
服务端和客户端底层使用Socket通信。客户端和服务端可能不在一台主机上。
常用的数据库有哪些？
mysql,oracle,db2,access,redis,mangodb
操作数据库的语言（SQL读音同circle，结构化查询语言）
DDL 数据定义语言
DML 数据操作语言
DQL 数据查询语言
TCL 事务控制语言
数据库的常用操作：CRUD，增删改查
C create 增
R retrieve 查
U update 改
D delete 删
数据库中数据长什么样？
数据库的数据都是以表格的方式呈现。
表的命名，习惯性使用复数。
在安装数据库的电脑上运行Command Line Client
mysql>show databases;查看所有的数据库
use mysql; 进入mysql这个数据库
show tables; 查看所有的表。
exit; 退出
mysql默认端口号：3306
Oracle默认端口是：1521
基本查询
sql语言不区分大小写，但是，习惯性的将关键字写为大写。
select * from books--查询books表中所有的数据
select name,stock from books--查询books表中的指定的列（name,stock）
select name 书名,stock as 库存 from books--查询books表中指定的列，为列取别名。
select name as "书 名" from books--别名中有空格的情况
select
id,name,stock,publishedby
from
books
where
id=5 >,<,<=,>=,!=,<>
从books表中查询id为5的图书的序号，书名，库存，出版社
select
id,name,stock,publishedby
from
books
where
id=3 or id=7 or id=8
从books表中查询id为3，7，8的图书的序号，书名，库存，出版社
select
id,name,stock,publishedby
from
books
where
id in (3,7,8)
从books表中查询id为3，7，8的图书的序号，书名，库存，出版社
select
id,name,stock,publishedby
from
books
where
id>3 and stock <10
同时满足多个条件
select name,stock,publishedby
from books
where publishedby is null
查询出版社为空的图书信息
select *
from books
where name='妈妈'
在sql中使用单引号来表示字符串
select *
from books
where name like '_好'
模糊查询使用_匹配单个字符，使用%匹配若干个字符
select *
from books
where id >3
order by price asc
查询结果以price的升序排序，降序把asc改为desc
select * from books
order by stock desc, price asc
按库存的降序排，如果库存一样，就按价格的升序排列
select COUNT(id)
from books
计数
select avg(price),sum(price)
from books
平均值，总和。
select DISTINCT(publishedby)
from books
去重
select count(DISTINCT(publishedby))
from books
先去重，再计数
select *
from books
limit 3,3
显示部分结果，第一个参数是从第几个开始（下标从0开始），第二个参数是显示多少个数据。
select count(id),publishedby
from books
group by publishedby
使用group by把结果进行分组
select avg(price),sum(price),publishedby
from books
group by publishedby
having publishedby = '人民出版社'
使用having来筛选group by 的某个组
select avg(price),publishedby
from books
where name like '%吗%'
group by publishedby
having publishedby = '人民出版社'
查询人民出版社出版的带有吗字的书的平均价格