Java

廖雪峰java基础课程笔记

2019-07-11  本文已影响0人  火影启源
JAVA.jpg

代码地址：https://github.com/jiaoqiyuan/liaoxuefeng_javase
代码基于 JDK8 编写。
笔记配合代码一起看，实际运行一下效果会更好。

java面向对象编程

数据封装

构造方法

方法重载

继承和多态

继承

多态

抽象类和接口

抽象方法

接口

abstra class interface
继承 只能extends一个clas 可以implements多个interface
字段 可以定义实例字段 不能定义实例字段
抽象方法 可以定义抽象方法 可以定义抽象方法
非抽象方法 可以定义非抽象方法 可以定义default方法

包和classpath

静态字段和方法

用static修饰的字段为静态字段

用static修饰的方法成为静态方法

静态方法通常用于工具类

静态方法通常用于辅助方法

Java程序入口函数main()也是静态方法

作用域

classpath & jar

classpath设定方法：

jar包

java核心类

字符串和编码

String特点：

StringBuilder

StringBuffer

包装类型

java数据类型：

基本类型不可以当作一个对象，要想以对象访问，就需要包装类型
JDK为每种类型都创建类对应的包装类型

基本类型 对应的引用类型
boolean Boolean
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character

例如：

Integer n = new Integer(99);
int i = n.intValue();

int i = 100;

Integer n1 = new Integer(i);
Integer n2 = Integer.valueOf(i);
Integer n3 = Integer.valueOf("100");

int x1 = n1.intValue();
int x2 = Integer.parseInt("100");
String s = n1.toString();

//注意这个getInteger，并不是从字符串中获取整数，而是从系统环境变量中获取相应的值
Integer prop = Integer.getInteger("cpus");

JavaBean

枚举类

常用工具类

Math

Math提供了数学计算的静态方法

long MIN = 1000;
long MAX = 9000;
double x2 = Math.random() * (MAX - MIN) + MIN;
double r = (long) x2;

Random

Random用来创建伪随机数

SecureRandom

SecureRandom用于创建安全的随机数，缺点是比较慢

BigInteger

BigInteger用任意多个int[]来表示非常大的整数。

BigDecimnal

BigDecimal表示任意精度的浮点数。
BigInteger和BigDecimnal多用于财务计算中。

Java异常处理

错误处理

Java的异常

Java异常体系：

断言和日志

断言

Logging

Commons Logging

Log4j

Java反射与泛型

反射

Class类

访问字段

调用方法

调用构造方法

获取继承关系

泛型

什么是泛型

使用泛型

编写泛型

public class Pair<T> {...}

public static <K> Pair<K> create(K first, K last) {...}

public class Pair<T, K> {...}

擦拭法

Java类型与反射

Java集合

Java集合简介

Java集合简介

List

使用List

ArrayList LinkedList
获取指定元素 速度很快 需要从头开始查找元素
添加删除元素 速度很快 速度很快
在指定位置添加/删除 需要移动元素 不需要移动元素
内存占用 少 较大

list的特点

编写equals方法

如果在List中查找元素：

如果不在List中查找元素：

Map

使用Map集合

编写eauals和hashCode方法

Set集合

使用Set

Queue

使用Queue

throw Exception 返回false或null
添加元素到队列 add(E e) boolean offer(E e)
取队首元素并删除 E remove() E poll()
取队首元素但不删除 E element() E peek()

-避免把null添加到队列

使用PriorityQueue

使用Deque

Queue Deque
添加元素到队尾 add(E e)/offer(E e) addLast(E e)/offerLast(E e)
取队首元素并删除 E remove()/E poll() E removeFirst()/E pollFirst()
取队首元素但不删除 E element()/E peek() E getFirst()/E peekFirst()

Deque特有方法：

Queue
添加元素到队首 addFirst(E e)/offerFirst(E e)
取队尾元素并删除 E removeLast()/E pollLast()
取队尾元素但不删除 E getLast()/E peekLast()

Stack

使用Stack

最佳实践

Iterator迭代模式

使用Collections

Java IO编程

IO基础

IO简介

抽象类 InputStream OutputStream Reader Writer
实现类 FileInputStream FileOutputStream FileReader FileWriter

File对象

InputStream

OutputStream

Filter模式

操作Zip

classpath资源

序列化

Reader

java.io.Reader和java.io.InputStream的区别：

InputStream Reader
字节流，以byte为单位 字符流，以char为单位
读取字节（-1，0-255）：int read() 读取字符(-1, 0-65535):int read()
读到字节数组:int read(byte[] b) 读到字符数组:int read(char[] c)
int read(byte[] b, int offset, int len) int read(char[] c, int offset, int len)

Writer

java.io.Writer和java.io.OutputStream的区别：

OutputStream Writer
字节流，以byte为单位 字符流，以char为单位
写入字节（0-255）：void write(int b) 写入字符(0-65535):int write()
写入字节数组:int write(byte[] b) 写入字符数组:int write(char[] c)
int write(byte[] b, int offset, int len) int write(char[] c, int offset, int len)
void write(String s)

Java处理日期和时间

概念

概念

java.util.Date

java.util.date的问题：

总结

Calendar

java.time的API

LocalDateTime

ZonedDateTime

ZonedDateTime = LocalDateTime + Zoneld

Java处理日期和时间

最佳实践，java处理日期和时间

数据库 对应Java类（旧） 对应Java类（新）
DATETIME java.util.Date LocalDateTime
Date java.sql.Date LocalDate
TIME java.sql.Time LocalTime
TIMESTAMP java.sql.Timestamp LocalDateTime 
String epochToString(long epoch, Local lo, String zoneId) {
    Instant ins = Instant.ofEpochMilli(epoch);
    DateTimeFormatter f = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM, FormatStyle.SHORT);
    return f.withLocale(lo).format(ZonedDateTime.ofInstant(ins, ZoneId.of(zoneId)));
}

输入：
epoch = 1480468500000L
Locale.CHINA, "Asia/Shanghai"
Locale.US, "America/New_York"

输出：
2016-11-30 上午9:15
Nov 29, 2016 8:15 PM

JUnit单元测试

JUnit简介

JUnit Test

版本 JUnit 3.x JUnit 4 JUnit 5
JDK JDK < 1.5 JDK >= 1.5 JDK >= 1.8
class class MyTest extends TestCase{} class MyTest{} class MyTest{}
method public testAbc(){} @Test public abc(){} @Test public abc(){}

使用JUnit

使用Before和After

异常测试

参数化测试

超时测试

Java正则表达式

正则表达式入门

正则表达式简介

匹配规则

正则表达式匹配规则：

正则表达式 规则 可以匹配
A 指定字符 A
\u548c 指定Unicode字符 和
. 任意字符 a, b, &, 0
\d 0-9 0, 1, 2, ..., 9
\w a-z, A-Z, 0-9, _ a, A, 0, _, ...
\s 空格，Tab键 ' '， ' '
\D 非数字 a, A, &, _, ...
\W 非\w &, @, 中, ...
\S 非\s a, A, @, _, ...
AB* 匹配任意个数字符 A，AB, ABB, ABBB, ...
AB+ 至少一个字符 AB, ABB, ABBB, ...
AB? 0个或1个字符 A，AB
AB{3} 指定个数字符 ABBB
AB{1, 3} 指定范围个数字符 AB, ABB, ABBB
AB{2, } 至少n个字符 ABB, ABBB, ...
AB{0, 3} 最多n个字符 A, AB, ABB, ABBB

正则表达式进阶

复杂正则表达式

复杂规则：

正则表达式 规则 可以匹配
^ 开头 字符串开头
$ 结尾 字符串结束
[ABC] [...] 内任意字符 A, B, C
[A-F0-9xy] 指定范围的字符 A, ..., F, 0, ..., 9, x, y
[^A-F] 指定范围外的任意字符 非A, ..., F
AB|CD AB或CD AB, CD
AB|CD|EFG AB或CD或EFG AB, CD, EFG

分组匹配

非贪婪匹配

^(\d+)(0*)$

期望结果：

input \d+ 0*
123000 "123" "000"
10100 "101" "00"
1001 "1001" ""

实际结果：

input \d+ 0*
123000 "123000" ""
10100 "10100" ""
1001 "1001" ""

因为正则表达式默认使用贪婪匹配，会尽可能多地向后匹配，使用?实现费贪婪匹配，^(\d+?)(0*)$

^(\d+??)(9*)$ ：第一个?表示匹配0个或1个9，第二个?表示费贪婪匹配，所以会尽可能少地匹配9。
如果待匹配字符串是'9999'，则匹配0个9

搜索和替换

"a b c".split("\\s")    //{"a", "b", "c"}
"a b  c".split("\\s")    //{"a", "b", "", "c"}
"a b  c".split("\\s+")    //{"a", "b", "c"}
"a, b ;; c".split("[\\,\\;\\s]+")    //{"a", "b", "c"}

Java加密与安全

数据安全简介

加密与安全

编码算法

URL编码

Base64

摘要算法

MD5

SHA-1

SHA-1算法：

BouncyCastle

Hmac

加密算法

对称加密算法

口令加密

PBE:Password Based Encryption

密钥交换算法

非对称加密算法

签名算法

RSA签名算法

数字证书

Java多线程编程

线程的概念

多线程编程

进程和线程的关系

实现多任务的方法：

多进程 VS 多线程

Java语言内置多线程支持：

多线程编程的特点：

Java多线程编程的特点：

创建Java多线程

java语言内置多线程支持：

创建一个线程对象，并启动一个线程

Thread t = new Thread();
t.start();

线程的状态

中断线程

守护线程

线程同步

synchronized方法

死锁

wait和notify

高级concurrent包

ReentrantLock

ReadWriteLOck

Condition

Concurrent集合

| Interface | Non-thread safe | Thread safe |
| :---: | :---: | :--- : |
| List | ArrayList | CopyOnWriteArrayList |
| Map | HashMap | ConcurrentHashMap |
| Set | HashSet, TreeSet | CopyOnWriteArraySet |
| Queue | ArrayDeque, LinkedList | ArrayBlockingQueue, LinkedBlockingQueue |
| Deque | ArrayDeque, LinkedList | LinkedBlockingDeque |

Map unsafeMap = new HashMap();
Map threadSafeMap = Collections.synchronizedMap(unsafeMap);

Atomic

ExecutorService

Future

CompletableFuture

Fork / Join

线程工具类

ThreadLocal

Java网络编程

Socket编程

网络编程概念

计算机网络基本概念

TCP编程

TCP编程模型

TCP多线程编程

UDP编程

UDP编程模型

Email编程

发送Email

SMTP协议

如何发送Email

接受Email

HTTP协议

RMI远程调用

-目的是把一个接口暴露给远程

Java操作XML和JSON

XML

XML介绍

DOM

SAX

第三方XML库

JSON

JSON介绍

处理JSON

JDBC编程

关系数据库基础

关系数据库简介

安装MySQL

SQL入门

SQL简介

INSERT语句

INSERT INTO 表名 (字段1, 字段2, ...) VALUES (数据1, 数据2, 数据3, ...)

SELECT

UPDATE语句

DELETE语句

JDBC接口

JDBC简介

JDBC查询

JDBC更新

数据库事物 Transaction

JDBC连接池

Java函数式编程

Lambda表达式

Lambda基础

Method Reference

Stream

Stream简介

java.io java.util.stream
存储 顺序读写的byte / char 顺序输出的任意Java对象
用途 序列化至文件 / 网络 内存计算 / 业务逻辑
java.util.List java.util.stream
元素 已分配并存储在内存 未分配，实时计算
用途 操作一组已存在的Java对象 惰性计算

创建Stream

Stream<Integer> s = Stream.of(1, 2, 3, 4, 5);
Stream<Integer> s = Arrays.stream(theArray);
Stream<Integer> s = aList.stream();

Stream<T> s = Stream.generate(Supplier<T> s);

try(Stream<String> lines = Files.lines(Paths.get("/path/to/access.log"))){
    ...
}
Files的lines也可以创建一个Stream

Stream.map

Stream.filter()

reduce

其他操作

Stream<T> sorted()  //按元素默认大小进行排序（必须实现Comparable接口）
Stream<T> sorted(Comparable<? super T> cp)  //按指定Comparable比较的结果排序

Stream<T> distinct()    //返回去除重复元素的新Stream
// [1, 2, 3, 4, 5, 4, 3] -> [1, 2, 3, 4, 5]

Stream<T> limit(long)   //截取当前Stream的最多n个元素
Stream<T> skip(long)    //跳过当前Stream的前N个元素

Stream<T> s = Stream.concat(
    Stream.of(1, 2, 3)
    Stream.of(4, 5, 6)
);
// 1, 2, 3, 4, 5, 6

Stream<List<Integer>> s = Stream.of)
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9));

// 转换为Stream<Integer>
Stream<Integer> i = s.flatMap(list -> list.stream())

| 1 2 3 | 4 5 6 | 7 8 9
|:---:| :--- : | :---:
| | flatMap |
| | 1 2 3 4 5 6 7 8 9 |

Stream<String> s = ...
String[] result = s.parallel()  // 贬称一个可以并行处理的Stream
                    .sorted()   // 可以进行并行排序
                    .toArray(String[]::new);

Optional<T> reduce(BinaryOperator<T> bo)
long count()    //元素个数

T max(Comparator<? super T> cp)     //找最大元素
T min(Comparator<? super T> cp)     //找最小元素

// 针对IntStream / LongStream / DoubleStream
sum()   //求和
average()   //求平均数


boolean allMatch(Predicate<? super T>)  //所有元素均满足条件？
boolean anyMatch(Predicate<? super T>)  //至少有一个元素满足测试条件？

void forEach(Consumer<? super T> action)

//示例
Stream<String> s = ...
s.forEach(str -> {
    System.out.println("Hello, " + str);
});

Object[] toArray()  //转换为Object数组
A[] toArray(IntFunction<A[]>)    //转换为A[]数组
<R, A> R collect(Collector<? super T, A, R> collector)  //转换为List/Set等集合类型

//示例
Stream<String> s = ...
String[] arr = s.toArray(String[]::new) //转换为String数组
List<String> list = s.collect(Collectors.toList)    //转换为List

结束

继续努力！

2018.08.28 北京 晴

上一篇 下一篇

猜你喜欢

热点阅读