Collection

  • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
// ---------- 1. 创建:面向接口编程 ----------
Collection<String> c = new ArrayList<>(); // List:可重复、可 null
Collection<String> set = new HashSet<>(); // Set:不重复,add 已存在返回 false

// ---------- 2. 添加:boolean = 集合是否真的发生了变化 ----------
boolean b1 = c.add("A"); // true
boolean b2 = c.add("B"); // true
boolean b3 = c.add("A"); // List:true / Set:false(重复被拒绝)
c.addAll(List.of("X", "Y")); // 参数必须是一个集合,不是可变参数

// ---------- 3. 查询 ----------
int n = c.size(); // 元素个数,返回 int
boolean empty = c.isEmpty(); // 是否为空
boolean has = c.contains("A"); // 依赖 equals();自定义对象必须重写 equals/hashCode
boolean all = c.containsAll(List.of("A","B")); // 是否包含全部

// ---------- 4. 删除:按对象删,没有索引概念 ----------
boolean r1 = c.remove("A"); // 只删第一个 equals 匹配的,返回是否删成功
// remove(Object) 不是按索引!List 才有 remove(int index)
Collection<Integer> nums = new ArrayList<>();
nums.add(0); nums.add(1);
nums.remove(0); // 删的是值为 0 的元素,不是第 0 个
((List<Integer>)nums).remove(0); // 想按索引删必须转成 List

c.removeAll(List.of("A","B")); // 差集:删掉所有在参数集合里出现的
c.retainAll(List.of("X")); // 交集:只保留参数集合里也有的
c.clear(); // void,清空后 size()==0(容量不变,引用置 null 才彻底释放)

// ---------- 5. 条件删除(JDK8+,最推荐,不会抛并发异常)----------
c.removeIf(s -> s == null); // 参数是 Predicate,不是具体元素
c.removeIf(s -> s.startsWith("A"));

// ---------- 6. 遍历 + 安全删除:唯一能用集合自身删除的方式是迭代器 ----------
Iterator<String> it = c.iterator();
while (it.hasNext()) {
String s = it.next();
if (s.length() > 3) it.remove(); // 正确
// c.remove(s); // ConcurrentModificationException
}
for (String s : c) { ... } // 增强 for 底层就是 iterator,同样不能 add/remove

// ---------- 7. 转数组 / 转流 ----------
Object[] a1 = c.toArray();
String[] a2 = c.toArray(new String[0]);
c.stream().filter(...).forEach(...); // JDK8+

// ---------- 8. 其他注意事项 ----------
// · 泛型不能写基本类型:Collection<Integer> Collection<int>
// · null:ArrayList/LinkedList 允许多个 null;HashSet 只允许一个;TreeSet 不允许(比较抛 NPE)
// · Set 判断重复:equals() + hashCode() 都要重写
// · 批量方法 removeAll/retainAll/containsAll/addAll 参数都是 Collection,别写成可变参数
// · size() 返回 int,超大集合理论上会溢出(一般不用管)

迭代器以及遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
Collection<String> c = new ArrayList<>(List.of("A", "BB", "CCC", "DDDD"));

// ==================== 1. 增强 for(最常用,只读场景)====================
// 底层 = iterator,语法糖;简洁但遍历时不能 add/remove,否则 ConcurrentModificationException

for (String s : c) {
System.out.println(s); // s 是局部副本变量,修改 s 不影响集合元素
}
// 增强 for 里没有索引变量,需要序号时自己维护:
int i = 0;
for (String s : c) { System.out.println(i++ + ":" + s); }

// ==================== 2. Lambda / forEach(JDK8+,本质还是迭代器)====================
// Collection 继承 Iterable,默认方法 void forEach(Consumer<? super T> action)
c.forEach(s -> System.out.println(s));
c.forEach(System.out::println); // 方法引用,更短
c.forEach((String s) -> { System.out.println(s); }); // 多语句加大括号

// 常见变形
c.forEach(s -> { if (s.length() > 2) System.out.println(s); });
// 累加/统计(注意:lambda 内引用的局部变量必须 effectively final)
StringBuilder sb = new StringBuilder();
c.forEach(sb::append);

// 条件删除用 removeIf(也是 Consumer/Predicate 系,唯一能在 lambda 里安全删的方式)
c.removeIf(s -> s.length() > 2); // 安全
// c.forEach(s -> { if (...) c.remove(s); }); // ConcurrentModificationException

// lambda 三大坑:
// 1) 不能 break / continue(没有循环体概念)→ 改用 stream().anyMatch / 普通 for
// 2) 不能 return 跳出外层(return = continue),也不能 throw 受检异常
// 3) 捕获的局部变量隐式 final,不能在 lambda 里改外部计数变量(用 AtomicInteger 或数组绕)

// ==================== 3. Iterator 迭代器(唯一能在遍历中安全删除的方式) ====================

Iterator<String> it = c.iterator(); // 每次调用返回新的迭代器,从头开始
while (it.hasNext()) { // 先判断,再取
String s = it.next(); // next() 只调一次,调两次会跳元素/抛 NoSuchElementException

if (s == null) continue;
if (s.length() > 2) {
it.remove(); // 必须用迭代器自己的 remove,且必须在 next() 之后调用
}
}
// it.remove(); // IllegalStateException(还没 next 或已 remove 过一次)
// c.add("X"); // 迭代过程中用集合自身增删 → ConcurrentModificationException

// 带索引的写法(仅 List 有 ListIterator,支持双向 + 添加)
ListIterator<String> lit = ((List<String>)c).listIterator();
while (lit.hasNext()) {
int idx = lit.nextIndex(); // 当前元素下标
String s = lit.next();
if (s.length() > 2) lit.remove(); // 安全删除
else lit.add("X"); // 安全插入(Iterator 没有 add)
}
lit.hasPrevious(); lit.previous(); // 反向遍历

// ==================== 4. 对比速查 ====================
// 方式 能否拿索引 能否安全删除 能否 break 写法
// 增强 for 否 否 能 最简
// forEach(Lambda) 否 否(用removeIf能) 否 最简+可链式
// Iterator 否 能 能 略啰嗦但功能最全
// ListIterator 能 能 能 仅 List
// 普通 for(i) 能(倒序删才安全) 能 仅 List,删除要注意下标前移

// 普通 for 删除的正确姿势(List 专属):倒序遍历,避免下标错位漏元素
List<String> list = new ArrayList<>(c);
for (int i = list.size() - 1; i >= 0; i--) {
if (list.get(i).length() > 2) list.remove(i); // 正序删会漏掉相邻元素
}

List集合

方法名 描述
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素,返回被删除的元素
E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
E get(int index) 返回指定索引处的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// remove 优先调用,实参和形参类型一致的方法。
List<Integer> li = new ArrayList<>();
li.add(1);
li.add(2);
li.remove(1); // 这个是索引 1,如果要是本身删除 Integer.valueOf(1);

// 列表迭代器
//获取一个列表迭代器的对象,里面的指针默认也是指向 0 索引的
//额外添加了一个方法:在遍历的过程中,可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
String str = it.next();
if("bbb".equals(str)){
//qqq
it.add("qqq");
}
}

LinkedList

方法名 说明
public void addFirst(E e) 在该列表开头插入指定的元素
public void addLast(E e) 将指定的元素追加到此列表的末尾
public E getFirst() 返回此列表中的第一个元素
public E getLast() 返回此列表中的最后一个元素
public E removeFirst() 从此列表中删除并返回第一个元素
public E removeLast() 从此列表中删除并返回最后一个元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class MyLinkedListDemo4 {

public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// public void addFirst(E e) 在该列表开头插入指定的元素
//method1(list);

// public void addLast(E e) 将指定的元素追加到此列表的末尾
// method2(list);

// public E getFirst() 返回此列表中的第一个元素
// public E getLast() 返回此列表中的最后一个元素
// method3(list);

// public E removeFirst() 从此列表中删除并返回第一个元素
// public E removeLast() 从此列表中删除并返回最后一个元素
// method4(list);
}

private static void method4(LinkedList<String> list) {
String first = list.removeFirst();
System.out.println(first);

String last = list.removeLast();
System.out.println(last);

System.out.println(list);
}

private static void method3(LinkedList<String> list) {
String first = list.getFirst();
String last = list.getLast();
System.out.println(first);
System.out.println(last);
}

private static void method2(LinkedList<String> list) {
list.addLast("www");
System.out.println(list);
}

private static void method1(LinkedList<String> list) {
list.addFirst("qqq");
System.out.println(list);
}
}

泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/* 泛型是JDK5中引入的特性,它提供了编译时类型安全检测机制
泛型只支持引用类型
指定泛型的具体类型后,传递数据时,可以传入该类类型或其子类类型
如果不写泛型,类型默认是 Object
*/
// 泛型类
class Box<T> {
private final T value;
Box(T value) { this.value = value; }
T get() { return value; }
}

// 泛型接口
@FunctionalInterface
interface Converter<T, R> {
R convert(T t);
}

// 泛型方法
class Utils {
static <T> T first(List<T> list) {
return list.get(0);
}

static <T extends Comparable<T>> T max(T a, T b) {
return a.compareTo(b) >= 0 ? a : b;
}
}

// 使用
Box<String> box = new Box<>("hello");
String s = box.get();
Converter<String, Integer> len = String::length; // 类名::实例方法(省去参数和括号的冗余)
Converter<String, Integer> len2 = str -> str.length(); // Lambda 写法
Integer n = len.convert("java");
List<Integer> nums = List.of(1, 2, 3);
Integer first = Utils.first(nums);
Integer max = Utils.max(3, 7);

// ---------- 泛型不具备继承性,但是数据具备继承性 ----------
class Ye {}
class Fu extends Ye {}
class Zi extends Fu {}
// 创建集合对象
ArrayList<Ye> list1 = new ArrayList<>();
ArrayList<Fu> list2 = new ArrayList<>();
ArrayList<Zi> list3 = new ArrayList<>();
method(list1); // OK,类型完全一致 ArrayList<Ye>
// method(list2); // 编译错误!ArrayList<Fu> 不是 ArrayList<Ye> 的子类
// method(list3); // 编译错误!ArrayList<Zi> 不是 ArrayList<Ye> 的子类
list1.add(new Ye());
list1.add(new Fu());
list1.add(new Zi());
public static void method(ArrayList<Ye> list) {}

// ---------- 4. 通配符 ----------
// ? extends Number:元素是 Number 或其子类,适合读,不适合写
double sum(List<? extends Number> list) {
double total = 0;
for (Number num : list) total += num.doubleValue();
return total;
}
sum(List.of(1, 2, 3)); // List<Integer> OK
sum(List.of(1.5, 2.5)); // List<Double> OK

// ? super Integer:元素是 Integer 或其父类,适合写,读只能读成 Object
void addInts(List<? super Integer> list) {
list.add(1); // OK
Object o = list.get(0); // 只能读成 Object
}
List<Number> numberList = new ArrayList<>();
addInts(numberList); // List<Number> OK
addInts(new ArrayList<Object>()); // List<Object> OK

// ---------- 5. PECS 原则 ----------
// 生产者用 extends(只读),消费者用 super(只写)
static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (T t : src) dest.add(t);
}
// 通配符 ? extends T:接收 T 或 T 的子类列表,读取安全
// 通配符 ? super T:接收 T 或 T 的父类列表,写入安全

数据结构

  • 栈结构:先进后出,后进先出
  • 队列结构:先进先出,后进后出
  • 数组结构:查询快、增删慢
  • 链表结构:查询慢、增删快

二叉树

  • 二叉树中,任意一个节点的度要小于等于2
    • 节点:在树结构中,每一个元素称之为节点
    • 度:每一个节点的子节点数量称之为度

二叉查找树

  • 每一个节点上最多有两个子节点
  • 左子树上所有节点的值都小于根节点的值
  • 右子树上所有节点的值都大于根节点的值

添加节点规则:小的存左边,大的存右边,一样的不存

遍历:

  • 前序遍历:当前节点,左子节点,右子结点
  • 中序遍历:左子节点,当前节点,右子结点
  • 后序遍历:左子节点,右子结点,当前节点
  • 层序遍历:一层一层的去遍历

平衡二叉树

  • 二叉树左右两个子树的高度差不超过1
  • 任意节点的左右两个子树都是一颗平衡二叉树

左旋:就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点

右旋:就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点

平衡二叉树旋转的四种情况

  • 左左
    • 左左:当根节点左子树的左子树有节点插入,导致二叉树不平衡
    • 如何旋转:直接对整体进行右旋即可
  • 左右
    • 左右:当根节点左子树的右子树有节点插入,导致二叉树不平衡
    • 如何旋转:先在左子树对应的节点位置进行左旋,在对整体进行右旋
  • 右右
    • 右右:当根节点右子树的右子树有节点插入,导致二叉树不平衡
    • 如何旋转:直接对整体进行左旋即可
  • 右左
    • 右左:当根节点右子树的左子树有节点插入,导致二叉树不平衡
    • 如何旋转:先在右子树对应的节点位置进行右旋,在对整体进行左旋

红黑树

  • 平衡二叉B树
  • 每一个节点可以是红或者黑
  • 红黑树不是高度平衡的,它的平衡是通过“自己的红黑规则”进行实现的

红黑规则

  1. 每一个节点或是红色的,或者是黑色的
  2. 根节点必须是黑色
  3. 红黑树中,所有空指针(null)在逻辑上均被视为指向一个黑色的虚拟叶子节点(NIL/哨兵节点),它不存数据,仅作为路径终点统一黑高计算基准。
  4. 如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
  5. 对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点

红黑树添加节点的默认颜色:添加节点时,默认为红色,效率高

保持红黑规则:

  • 根节点位置:直接变为黑色
  • 非根节点位置
    • 父节点为黑色
      • 不需要任何操作,默认红色即可
    • 父节点为红色
      • 叔叔节点为红色
        • 将“父节点”设为黑色,将“叔叔节点”设为黑色
        • 将“祖父节点”设为红色
        • 如果“祖父节点”为根节点,则将根节点再次变成黑色
      • 叔叔节点为黑色(当前节点是父的右孩子)
        • 把父作为当前节点并左旋,再进行判断
      • 叔叔节点为黑色(当前节点是父的左孩子)
        • 将“父节点”设为黑色
        • 将“祖父节点”设为红色
        • 以“祖父节点”为支点进行右旋转

Set

无序、不重复、无索引

  • 不可以存储重复元素
  • 没有索引,不能使用普通for循环遍历
1
2
3
4
5
6
7
8
9
10
11
12
Set<String> set = new TreeSet<>(); //创建集合对象
set.add("aaa"); //添加元素
//遍历集合
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}

for (String s : set) {
System.out.println(s);
}

HashSet:无序、不重复、无索引

LinkedHashSet:有序(存储和取出的元素顺利一致)、不重复、无索引

TreeSet:可排序、不重复、无索引

TreeSet():根据其元素的自然排序进行排序

TreeSet(Comparator comparator):根据指定的比较器进行排序


HashSet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* 哈希值:public int hashCode(),是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
JDK1.8以前:数组 + 链表;
JDK1.8以后:节点个数少于等于8个 数组 + 链表,节点个数多于8个 数组 + 链表 + 红黑树
没有重写 hashCode 方法,不同对象计算的 hash 值是不同的
重写 hashCode 方法,不同对象的只要属性值相同,hash 相同
在部分情况下,hash 会出现重复
*/
// HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
@Override
public boolean equals(Object o) {}
@Override
public int hashCode() {
return Objects.hash(color, age);
}

// 要求去重且存取有序,才使用 LinkedHashSet

TreeSet

TreeSet():根据其元素的自然排序进行排序

TreeSet(Comparator comparator):根据指定的比较器进行排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// 自然排序Comparable的使用
// 自定义的Student类实现Comparable接口,重写接口中的compareTo方法
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
@Override
public int compareTo(Student o) {
// 返回值:正数添加的元素this是大的存右边;负数添加的元素this是小的存左边,0 舍弃
//按照对象的年龄进行排序
//主要判断条件: 按照年龄从小到大排序
int result = this.age - o.age;
//次要判断条件: 年龄相同时,按照姓名的字母顺序排序
result = result == 0 ? this.name.compareTo(o.getName()) : result;
return result;
}
}
TreeSet<Student> ts = new TreeSet<>();
Student s1 = new Student("zhangsan",28);
Student s2 = new Student("lisi",27);

// 比较器排序Comparator的使用
public class Teacher {
private String name;
private int age;
public Teacher() { }
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
}
TreeSet<Teacher> teacherSet = new TreeSet<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
//o1表示现在要存入的那个元素
//o2表示已经存入到集合中的元素

//主要条件
int result = o1.getAge() - o2.getAge();
//次要条件
result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
return result;
}
});

Map

  • 双列集合,一个键对应一个值
  • 键不可以重复,值可以重复
方法名 说明
V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度,也就是集合中键值对的个数

获取功能

方法名 说明
V get(Object key) 根据键获取值
Set keySet() 获取所有键的集合
Collection values() 获取所有值的集合
Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// interface Map<K,V> K:键的类型;V:值的类型
Map<String,String> map = new HashMap<String,String>();
//添加元素
map.put("张无忌", "赵敏1");
map.put("郭靖", "黄蓉");
map.put("杨过", "小龙女");
// map.put("张无忌", "赵敏2"); 键存在覆盖原来的值,返回值被覆盖的值。

// Collection<V> values():获取所有值的集合
Collection<String> values = map.values();
for(String value : values) {
System.out.println(value);
}

//获取所有键的集合。用 keySet() 方法实现
Set<String> keySet = map.keySet();
//遍历键的集合,获取到每一个键。用增强for实现
for (String key : keySet) {
//根据键去找值。用get(Object key)方法实现
String value = map.get(key);
System.out.println(key + "," + value);
}

//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历键值对对象的集合,得到每一个键值对对象
for (Map.Entry<String, String> me : entrySet) {
//根据键值对对象获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "," + value);
}

// Lambda 表达式
// default void forEach(BiConsumer<? super k, ? super V> action)
map.forEach((key, value) -> System.out.println(key + "=" + value));

HashMap

  • HashMap底层是哈希表结构的
  • 依赖hashCode方法和equals方法保证键的唯一
  • 如果键要存储的是自定义对象,需要重写hashCode和equals方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Student {
private String name;
private int age;
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public int getAge() { return age; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}

HashMap<Student, String> hm = new HashMap<Student, String>();
Student s1 = new Student("林青霞", 30);
//遍历集合
Set<Student> keySet = hm.keySet();
for (Student key : keySet) {
String value = hm.get(key);
System.out.println(key.getName() + "," + key.getAge() + "," + value);
}

LinkedHashMap

由键决定:有序、不重复、无索引。

这里的有序指的是保证存储和取出的元素顺序一致


TreeMap

  • TreeMap底层是红黑树结构
  • 依赖自然排序或者比较器排序,对键进行排序
  • 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Student implements Comparable<Student>{
// ...
@Override
public int compareTo(Student o) {
//按照年龄进行排序
int result = o.getAge() - this.getAge();
//次要条件,按照姓名排序。
result = result == 0 ? o.getName().compareTo(this.getName()) : result;
return result;
}
}

// 创建TreeMap集合对象
TreeMap<Student,String> tm = new TreeMap<>();
// 遍历TreeMap集合,打印每个学生的信息
tm.forEach(
(Student key, String value)->{
System.out.println(key + "---" + value);
}
);

可变参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 语法:类型... 参数名,必须是最后一个参数
void f(String s, int... nums) {
// nums 本质是 int[]
for (int n : nums) { ... }
}

// 调用
f("a"); // nums = new int[0]
f("a", 1, 2, 3); // nums = {1, 2, 3}
f("a", new int[]{1, 2}); // 也可直接传数组

/* 规则
1. 一个方法只能有一个可变参数
2. 必须放在参数列表最后
3. 不能和对应数组参数重载:f(int...) 与 f(int[]) 冲突
4. 固定参数方法优先:f(int, int) 优先于 f(int...)
5. 泛型可变参数可能有警告,可用 @SafeVarargs
*/

// 注意:null 表示 null 数组,不是空数组。方法内部当数组用,注意空指针

Collections类

  • java.utils.Collections 是集合工具类,用来对集合进行操作。

常用方法如下:

  • public static void shuffle(List<?> list) :打乱集合顺序。
  • public static <T> void sort(List<T> list) :将集合中元素按照默认规则排序。
  • public static <T> void sort(List<T> list,Comparator<? super T> ) :将集合中元素按照指定规则排序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class CollectionsDemo {

public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();

list.add(100);
list.add(300);
list.add(200);
list.add(50);
//排序方法
Collections.sort(list);
System.out.println(list);
}
}
// 结果:[50,100, 200, 300]

// Comparator 比较器
public class Student{
private String name;
private int age;
}
public class Demo {
public static void main(String[] args) {
// 创建四个学生对象 存储到集合中
ArrayList<Student> list = new ArrayList<Student>();

list.add(new Student("rose",18));
list.add(new Student("jack",16));
list.add(new Student("abc",20));
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();//以学生的年龄升序
}
});
for (Student student : list) {
System.out.println(student);
}
}
}
Student{name='jack', age=16}
Student{name='rose', age=18}
Student{name='abc', age=20}

不可变集合

是一个长度不可变,内容也无法修改的集合,只能进行查询操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 不可变的list集合
List<String> list = List.of("张三", "李四", "王五", "赵六");
// 不可变的Set集合
Set<String> set = Set.of("张三", "张三", "李四", "王五", "赵六");
// 不可变的Map集合,Map 的 of 方法最多传递20个参数。
Map<String, String> map = Map.of("张三", "南京", "张三", "北京");
// Map 键值对个数大于10
HashMap<String, String> hm = new HashMap<>();
hm.put("张三", "南京");
// ...
hm.put("陈二", "嘉兴");
/*
//获取到所有的键值对对象(Entry对象)
Set<Map.Entry<String, String>> entries = hm.entrySet();
//把entries变成一个数组
Map.Entry[] arr1 = new Map.Entry[0];
Map.Entry[] arr2 = entries.toArray(arr1);
//不可变的map集合
Map map = Map.ofEntries(arr2);
*/
// Map<Object, Object> map = Map.ofEntries(hm.entrySet().toArray(new Map.Entry[0]));
Map<String, String> immutableMap = Map.copyOf(hm);

Stream流

  • 中间方法:一次操作完毕之后,还可以继续进行其他操作
  • 终结方法:一个Stream流只能有一个终结方法,是流水线上的最后一个操作

生成Stream流的方式

  • Collection体系集合:使用默认方法stream()生成流, default Stream stream()
  • Map体系集合:把Map转成Set集合,间接的生成流
  • 数组:通过Arrays中的静态方法stream生成流
  • 同种数据类型的多个数据:通过Stream接口的静态方法of(T… values)生成流
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//Collection体系的集合可以使用默认方法stream()生成流
List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();

//Map体系的集合间接的生成流
Map<String,Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

//数组可以通过Arrays中的静态方法stream生成流
String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Arrays.stream(strArray);

//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);
//注意:
//Stream接口中静态方法of的细节
//方法的形参是一个可变参数,可以传递一堆零散的数据,也可以传递数组
//但是数组必须是引用数据类型的,如果传递基本数据类型,是会把整个数组当做一个元素,放到Stream当中。

int arr1 = {1, 2, 3};
String arr2 = {"a", "b", "c"}
Stream.of(arr1).forEach(s-> System.out.println(s));//[I@41629346

中间方法

方法名 说明
Stream filter(Predicate predicate) 用于对流中的数据进行过滤
Stream limit(long maxSize) 返回此流中的元素组成的流,截取前指定参数个数的数据
Stream skip(long n) 跳过指定参数个数的数据,返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流
Stream distinct() 返回由该流的不同元素(根据 Object.equals(Object) )组成的流
Stream Map(Function<T,R> mapper) 转换流中的数据类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("王祖贤");
/*
注意1:中间方法,返回新的Stream流,原来的Stream流只能使用一次,建议使用链式编程
注意2:修改Stream流中的数据,不会影响原来集合或者数组中的数据
*/
// filter
list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));

// limit、skip
//需求1:取前3个数据在控制台输出
list.stream().limit(3).forEach(s-> System.out.println(s));
System.out.println("--------");
//需求2:跳过3个元素,把剩下的元素在控制台输出
list.stream().skip(3).forEach(s-> System.out.println(s));
System.out.println("--------");
//需求3:跳过2个元素,把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));

// concat、distinct
//需求1:取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//需求2:跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//需求3:合并需求1和需求2得到的流,并把结果在控制台输出
// Stream.concat(s1,s2).forEach(s-> System.out.println(s));
//需求4:合并需求1和需求2得到的流,并把结果在控制台输出,要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));

// map
ArrayList<String> strList = new ArrayList<>();
Collections.addAll(strList, "a-1", "b-2");
strList.stream().map(s -> Integer.parseInt(s.split("-")[1]));

终结方法

方法名 说明
void forEach(Consumer action) 对此流的每个元素执行操作
long count() 返回此流中的元素数
Object[] toArray() 返回包含此流元素的数组
1
2
3
4
5
6
7
8
9
// long 返回此流中的元素数
long count = list.stream().count();

// forEach
list.stream().forEach(s -> System.out.println(s));

// toArray
Object[] arr1 = list.stream().toArray();
String[] arr2 = list.stream().toArray(value -> new String[value]);

收集方法

方法名 说明
R collect(Collector collector) 把结果收集到集合中

工具类Collectors提供了具体的收集方式

方法名 说明
public static Collector toList() 把元素收集到List集合中
public static Collector toSet() 把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper) 把元素收集到Map集合中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
List<Integer> list1 = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 10, 10));

// toList: 收集到 List 集合(保留重复元素)
List<Integer> evenList = list1.stream()
.filter(number -> number % 2 == 0)
.collect(Collectors.toList());
// 输出: [2, 4, 6, 8, 10, 10, 10, 10, 10, 10]

// toSet: 收集到 Set 集合(自动去重)
Set<Integer> evenSet = list1.stream()
.filter(number -> number % 2 == 0)
.collect(Collectors.toSet());
// 输出: [2, 4, 6, 8, 10]

// toMap 需求:筛选年龄>=24岁的人,收集到Map中(姓名为键,年龄为值)
List<String> list2 = new ArrayList<>(List.of("zhangsan,23", "lisi,24", "wangwu,25"));

Map<String, Integer> ageMap = list2.stream()
.filter(s -> Integer.parseInt(s.split(",")[1]) >= 24) // 过滤年龄
.collect(Collectors.toMap(
s -> s.split(",")[0], // 键:姓名
s -> Integer.parseInt(s.split(",")[1]) // 值:年龄
));
// 输出: {lisi=24, wangwu=25}

/*
笔记要点:
1. collect() 负责收集流中剩余的数据,但不负责创建容器和添加数据。
2. Collectors.toList(): 底层创建 List 并添加数据,保留重复。
3. Collectors.toSet(): 底层创建 Set 并添加数据,自动去重。
4. Collectors.toMap(): 底层创建 Map,需要两个 Lambda(分别指定键 Key 和值 Value 的生成规则)。
*/

方法引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public class FunctionDemo1 {

public static void main(String[] args) {
Integer[] arr = {3, 5, 4, 1, 6, 2};
//1.引用处需要是函数式接口
//2.被引用的方法需要已经存在
//3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
//4.被引用方法的功能需要满足当前的要求
Arrays.sort(arr, FunctionDemo1::subtraction);
//可以是Java已经写好的,也可以是一些第三方的工具类
}
public static int subtraction(int num1, int num2) {
return num2 - num1;
}
}

// 引用类的静态方法(类名::静态方法)
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"1","2","3","4","5");
list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

// 引用类中的成员方法(对象::成员方法)
// 其他类 其他类对象::方法名
// 本类 super::方法名
// 父类 super::方法名
public class StringOperation {
public boolean stringJudge(String s){
return s.startsWith("张") && s.length() == 3;
}
}
public class FunctionDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰");
list.stream().filter(new FunctionDemo3()::stringJudge).forEach(s-> System.out.println(s));

// 静态方法中是没有this的,创建本类的对象
list.stream().filter(new FunctionDemo3()::stringJudge).forEach(s-> System.out.println(s));

public class StringOperation {...}
}
}

// 引用构造方法(类名::new)
public class Student {
private String name;
private int age;
public Student(String str) {
String[] arr = str.split(",");
this.name = arr[0];
this.age = Integer.parseInt(arr[1]);
}
}
List<Student> newList2 = list.stream().map(Student::new).collect(Collectors.toList());

// 其他方式
// 1.使用类名引用成员方法(类名::成员方法)
/* 注意:
被引用方法的形参,需要跟抽象方法的第二个形参到最后一个形参保持一致,返回值需要保持一致。
抽象方法形参的详解:
第一个参数:表示被引用方法的调用者,决定了可以引用哪些类中的方法
在Stream流当中,第一个参数一般都表示流里面的每一个数据。
假设流里面的数据是字符串,那么使用这种方式进行方法引用,只能引用String这个类中的方法
第二个参数到最后一个参数:跟被引用方法的形参保持一致,如果没有第二个参数,说明被引用的方法需要是无参的成员方法
局限性:
不能引用所有类中的成员方法。
是跟抽象方法的第一个参数有关,这个参数是什么类型的,那么就只能引用这个类中的方法。
*/
list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
// 2.数组的构造方法(数据类型[]::new)
// 细节:数组的类型需要和流中的数据类型保持一致
ArrayList<Integer> numList = new ArrayList<>();
Collections.addAll(numList, 1, 2, 3, 4, 5);
Integer[] arr2 = numList.stream().toArray(Integer[]::new);

异常

Throwable体系:

  • Error:严重错误Error,无法通过处理的错误,只能事先避免。
  • Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运行,是必须要处理的。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

  • 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
  • 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static void main(String[] args) throws ParseException {
//编译时异常(在编译阶段,必须要手动处理,否则代码报错)
*String time = "2030年1月1日";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
Date date = sdf.parse(time);
System.out.println(date);
}

//运行时异常(在编译阶段是不需要处理的,是代码运行时出现的异常)
int[] arr = {1,2,3,4,5};
System.out.println(arr[10]);//ArrayIndexOutOfBoundsException

// 抛出异常 throw new 异常类名(参数);
throw new RuntimeException();
throw new NullPointerException("要访问的arr数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在,已超出范围");

// 异常处理 try{...}catch(异常类型 e){}
int[] arr = {1, 2, 3, 4, 5};
try {
System.out.println(arr[5]); // 出现一个异常后,下面的代码不会执行。如果没被捕获会交给虚拟机进行处理。
System.out.println(2/0);
String s = null;
System.out.println(s.equals("abc"));
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组索引越界");
} catch(NullPointerException | ArithmeticException e){ // 在JDK7之后,中间用|进行隔开
System.out.println("索引越界了");
} catch (Exception e){
System.out.println("Exception");
} finally {
System.out.println("不管程序怎样,这里都将会被执行。");
}

异常方法

  • public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
  • public String toString():获取异常的类型和异常描述信息(不用)。
  • public void printStackTrace():打印异常的跟踪栈信息并输出到控制台
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// throws 运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)。
// 修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }
// 编译时异常必须写,运行时异常可以不写
public static void main(String[] args) throws FileNotFoundException {
read("a.txt");
}

// 自定义异常
public class LoginException extends Exception {
// 空参构造
public LoginException() {}
// 表示异常提示
public LoginException(String message) {
super(message);
}
}

File类

  • public File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
  • public File(String parent, String child):从父路径名字符串和子路径名字符串创建新的 File实例。
  • public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的 File实例。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 文件路径名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname);
// 文件路径名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2);
// 通过父路径和子路径字符串
String parent = "d:\\aaa";
String child = "bbb.txt";
File file3 = new File(parent, child);
// 通过父级File对象和子路径字符串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);
// 一个 File 对象代表硬盘中实际存在的一个文件或者目录。
// 无论该路径下是否存在文件或者目录,都不影响 File 对象的创建。

常用方法

  • public String getAbsolutePath() :返回此File的绝对路径名字符串。
  • public String getPath() :将此File转换为路径名字符串。
  • public String getName() :返回由此File表示的文件或目录的名称。
  • public long length() :返回由此File表示的文件的长度。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class FileGet {
public static void main(String[] args) {
File f = new File("d:/aaa/bbb.java");
System.out.println("文件绝对路径:"+f.getAbsolutePath());
System.out.println("文件构造路径:"+f.getPath());
System.out.println("文件名称:"+f.getName());
System.out.println("文件长度:"+f.length()+"字节");
File f2 = new File("d:/aaa");
System.out.println("目录绝对路径:"+f2.getAbsolutePath());
System.out.println("目录构造路径:"+f2.getPath());
System.out.println("目录名称:"+f2.getName());
System.out.println("目录长度:"+f2.length());
}
}
/*
输出结果:
文件绝对路径:d:\aaa\bbb.java
文件构造路径:d:\aaa\bbb.java
文件名称:bbb.java
文件长度:636字节
目录绝对路径:d:\aaa
目录构造路径:d:\aaa
目录名称:aaa
目录长度:4096
*/
// API中说明:length(),表示文件的长度。但是File对象表示目录,则返回值未指定。

绝对路径和相对路径

  • 绝对路径:从盘符开始的路径,这是一个完整的路径。
  • 相对路径:相对于项目目录的路径,这是一个便捷的路径,开发中经常使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class FilePath {
public static void main(String[] args) {
// D盘下的bbb.java文件
File f = new File("D:\\bbb.java");
System.out.println(f.getAbsolutePath());

// 项目下的bbb.java文件
File f2 = new File("bbb.java");
System.out.println(f2.getAbsolutePath());
}
}
输出结果:
D:\bbb.java
D:\idea_project_test4\bbb.java

判断功能的方法

  • public boolean exists() :此File表示的文件或目录是否实际存在。
  • public boolean isDirectory() :此File表示的是否为目录。
  • public boolean isFile() :此File表示的是否为文件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class FileIs {
public static void main(String[] args) {
File f = new File("d:\\aaa\\bbb.java");
File f2 = new File("d:\\aaa");
// 判断是否存在
System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
System.out.println("d:\\aaa 是否存在:"+f2.exists());
// 判断是文件还是目录
System.out.println("d:\\aaa 文件?:"+f2.isFile());
System.out.println("d:\\aaa 目录?:"+f2.isDirectory());
}
}
输出结果:
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 文件?:false
d:\aaa 目录?:true

创建删除功能的方法

  • public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。
  • public boolean delete() :删除由此File表示的文件或目录。
  • public boolean mkdir() :创建由此File表示的目录。
  • public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class FileCreateDelete {
public static void main(String[] args) throws IOException {
// 文件的创建
File f = new File("aaa.txt");
System.out.println("是否存在:"+f.exists()); // false
System.out.println("是否创建:"+f.createNewFile()); // true
System.out.println("是否存在:"+f.exists()); // true
// 目录的创建
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
// 创建多级目录
File f3= new File("newDira\\newDirb");
System.out.println(f3.mkdir());// false
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());// true
// 文件的删除
System.out.println(f.delete());// true
// 目录的删除
System.out.println(f2.delete());// true
System.out.println(f4.delete());// false
}
}
// API中说明:delete方法,如果此File表示目录,则目录必须为空才能删除。

目录的遍历

  • public String[] list() :返回一个String数组,表示该File目录中的所有子文件或目录。
  • public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或目录。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class FileFor {
public static void main(String[] args) {
File dir = new File("d:\\java_code");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//获取当前目录下的文件以及文件夹对象,只要拿到了文件对象,那么就可以获取更多信息
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
// 调用listFiles方法的File对象,表示的必须是实际存在的目录,否则返回null,无法进行遍历。

IO

IO的分类

根据数据的流向分为:输入流和输出流。

  • 输入流 :把数据从其他设备上读取到内存中的流。
  • 输出流 :把数据从内存 中写出到其他设备上的流。

格局数据的类型分为:字节流和字符流。

  • 字节流 :以字节为单位,读写数据的流。(一切文件数据)
  • 字符流 :以字符为单位,读写数据的流。(文本)
输入流 输出流
字节流 字节输入流 InputStream 字节输出流 OutputStream
字符流 字符输入流 Reader 字符输出流 Writer

字节流

字节输出流

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • public void close() :关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush() :刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b):将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) :从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。
  • public abstract void write(int b) :将指定的字节输出流。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/* FileOutputStream
public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name): 创建文件输出流以指定的名称写入文件。
*/
// public class FileOutputStreamConstructor throws IOException {...},抛出异常
// 使用File对象创建流对象
File file = new File("a.txt");
FileOutputStream fos = new FileOutputStream(file); // 每次创建新的文件会清空之前的
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("b.txt");
// 写出数据
fos.write(97); // 写出第1个字节
fos.write(98); // 写出第2个字节
// 字符串转换为字节数组
byte[] b = "黑马程序员".getBytes();
// 写出字节数组数据
fos.write(b);
// 字符串转换为字节数组
byte[] c = "abcde".getBytes();
// 写出从索引2开始,2个字节。索引2是c,两个字节,也就是cd。
fos.write(c,2,2);
// 关闭资源
fos.close();


/* 数据追加续写
public FileOutputStream(File file, boolean append): 创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name, boolean append): 创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean类型的值,true 表示追加数据,false 表示清空原有数据。这样创建的输出流对象,就可以指定是否追加续写了
*/
// 使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream("fos.txt",true);
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
// 写出从索引2开始,2个字节。索引2是c,两个字节,也就是cd。
fos.write(b);
// 写出换行:Windows系统里,换行符号是\r\n
// 定义字节数组
byte[] words = {97,98,99,100,101};
// 遍历数组
for (int i = 0; i < words.length; i++) {
// 写出一个字节
fos.write(words[i]);
// 写出一个换行, 换行符号转成数组写出
fos.write("\r\n".getBytes());
}

// 关闭资源
fos.close();

字节输入流

java.io.InputStream 抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

  • public void close() :关闭此输入流并释放与此流相关联的任何系统资源。
  • public abstract int read(): 从输入流读取数据的下一个字节。
  • public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/* FileInputStream
FileInputStream(File file): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
FileInputStream(String name): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
*/
// 使用File对象创建流对象
File file = new File("a.txt");
FileInputStream fos = new FileInputStream(file);
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("read.txt");
// 读取数据,返回一个字节
int read = fis.read();
System.out.println((char) read);
read = fis.read();
System.out.println((char) read);
read = fis.read();
// ...
// 读取到末尾,返回-1
read = fis.read();
System.out.println( read);
// 关闭资源
fis.close();

// 循环读取
// 读取了一个字节会自动提升为int类型。流操作完毕后,调用close方法。
int b;
while ((b = fis.read())!=-1) {
System.out.println((char)b);
}
// 关闭资源
fis.close();

// int read(byte[] b) 一次读一批字节,存进数组 b,返回实际读到的字节数。
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=-1) {
// 每次读取后,把数组的有效字节部分,变成字符串打印
// 所以要通过 len ,获取有效的字节(最后一次读取时,可能只填一部分)
System.out.println(new String(b,0,len));// len 每次读取的有效字节个数
}
// 关闭资源
fis.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 文件复制
FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
// 释放资源(规则:先开的最后关闭)
fos.close();
fis.close();

// IO异常的处理, 注意:只有实现了AutoCloseable接口的类,才能在小括号中创建对象。
// JDK7
public class HandleException2 {
public static void main(String[] args) {
// 创建流对象
try ( FileWriter fw = new FileWriter("fw.txt"); ) {
// 写出数据
fw.write("黑马程序员"); //黑马程序员
} catch (IOException e) {
e.printStackTrace();
}
}
}
// JDK9
public class TryDemo {
public static void main(String[] args) throws IOException {
// 创建流对象
final FileReader fr = new FileReader("in.txt");
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
// 定义变量
int b;
// 读取数据
while ((b = fr.read())!=-1) {
// 写出数据
fw.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

编码和解码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
Java中编码的方法
public byte[] getBytes() 使用默认方式进行编码
public byte[] getBytes(String charsetName) 使用指定方式进行编码

Java中解码的方法
String(byte[] bytes) 使用默认方式进行解码
String(byte[] bytes, String charsetName) 使用指定方式进行解码
*/

//1.编码
String str = "ai你哟";
byte[] bytes1 = str.getBytes();
System.out.println(Arrays.toString(bytes1));
byte[] bytes2 = str.getBytes("GBK");
System.out.println(Arrays.toString(bytes2));
//2.解码
String str2 = new String(bytes1);
System.out.println(str2);
String str3 = new String(bytes1,"GBK");
System.out.println(str3);

字符流

输入流

java.io.Reader 是字符输入流的超类,用于读取字符信息到内存。

核心方法:

  • close():关闭流并释放资源。
  • read():读取一个字符,返回 int,末尾返回 -1。
  • read(char[] cbuf):读取多个字符到数组,返回有效字符数,末尾返回 -1。

FileReader:读取字符文件的便利类。

构造:new FileReader(File file) 或 new FileReader(String fileName)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

try (Reader fr = new FileReader("read.txt")) {
char[] buf = new char[2];
int len;
while ((len = fr.read(buf)) != -1) {
System.out.print(new String(buf, 0, len));
}
}

// 一次读取多个
int len;
char[] cbuf = new char[2];
while ((len = fr.read(cbuf))!=-1) {
System.out.println(new String(cbuf,0,len));
}

输出流

java.io.Writer 是字符输出流的超类,用于写出字符信息到目的地。

  • write(int c):写一个字符。
  • write(char[] cbuf):写字符数组。
  • write(char[] cbuf, int off, int len):写字符数组一部分。
  • write(String str):写字符串。
  • write(String str, int off, int len):写字符串一部分。
  • flush():刷新缓冲,流可继续使用。
  • close():先刷新,再释放资源,之后不能再用。

FileWriter:写出字符到文件的便利类。

构造:new FileWriter(File/String) 默认清空;new FileWriter(File/String, true) 追加数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
fw.write(97); // 写出第1个字符
fw.write('b'); // 写出第2个字符
fw.write('C'); // 写出第3个字符
fw.write(30000); // 写出第4个字符,中文编码表中30000对应一个汉字。

/*
【注意】关闭资源时,与FileOutputStream不同。
如果不关闭,数据只是保存到缓冲区,并未保存到文件。
*/
fw.close();
// 刷新缓冲区,数据保存本地,流对象可以继续使用。
fw.flush();

char[] chars = "黑马程序员".toCharArray();
fw.write(chars); // 黑马程序员
// 字符串
String msg = "黑马程序员";
fw.write(msg); //黑马程序员
// 写出从索引2开始,2个字节。索引2是'程',两个字节,也就是'程序'。
fw.write(msg,2,2); // 程序

缓冲流

  • 字节缓冲流:BufferedInputStream,BufferedOutputStream
  • 字符缓冲流:BufferedReader,BufferedWriter

字节缓冲流

  • public BufferedInputStream(InputStream in) :创建一个 新的缓冲输入流。
  • public BufferedOutputStream(OutputStream out): 创建一个新的缓冲输出流。
1
2
3
4
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

字符缓冲流

  • public BufferedReader(Reader in) :创建一个 新的缓冲输入流。
  • public BufferedWriter(Writer out): 创建一个新的缓冲输出流。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

// public String readLine(): 读一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
}
// public void newLine(): 写一行行分隔符,由系统属性定义符号
bw.write("黑马");
// 写出换行
bw.newLine();

转换流

转换流:是 Reader、Writer 的子类,是从字节流到字符流的桥梁。Reader 它读取字节并使用指定的字符集将其解码为字符。Writer 使用指定的字符集将字符编码为字节。字符集可以由名称指定,也可以接受平台的默认字符集。

  • InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。

  • InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

  • OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。

  • OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。

1
2
3
4
5
6
7
8
9
10
11
12
// InputStreamReader
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
// 代替方案
FileReader fr = new FileReader("myio\\gbkfile.txt", Charset.forName("GBK"));
// OutputStreamWriter
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
FileWriter fw = new FileWriter("myio\\c.txt", Charset.forName("GBK"));
// 转成字符流,一次读一行
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("myio\\a.txt")));
br.readLine();

序列化

java.io.ObjectOutputStream 序列化类,将Java对象的原始数据类型写出到文件,实现对象的持久存储。

java.io.ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/* 一个对象要想序列化,必须满足两个条件:
该类必须实现java.io.Serializable 接口,Serializable 是一个标记接口,不实现此接口的类将不会使任何状态序列化或反序列化,会抛出NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient 关键字修饰。
*/
public class Employee implements java.io.Serializable {
public String name;
public String address;
public transient int age; // transient瞬态修饰成员,不会被序列化
public void addressCheck() {
System.out.println("Address check : " + name + " -- " + address);
}
}

Employee e = new Employee();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
out.writeObject(e);

// 对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个 ClassNotFoundException
Employee e = null;
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream("employee.txt"));
e = (Employee) in.readObject();
} catch(ClassNotFoundException c) {
// 捕获类找不到异常
c.printStackTrace();
return;
}

/* InvalidClassException 异常
该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法
*/
// 加入序列版本号:解决
private static final long serialVersionUID = 1L;
// 可以设置搜索Serializable,在 JVM 下勾选不带 'serialVersionUID' 的可序列化类,后右键类名可以生成

打印流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// 字节打印流 PrintStream 类构造方法:public PrintStream(String fileName) 
PrintStream ps = new PrintStream("ps.txt");
/*
字节打印流:
构造方法
public PrintStream(OutputStream/File/String) 关联字节输出流/文件/文件路径
public PrintStream(String fileName, Charset charset) 指定字符编码
public PrintStream(OutputStreamout, boolean autoFlush) 自动刷新
public PrintStream(OutputStream out, boolean autoFlush, String encoding) 指定字符编码且自动刷新
成员方法:
public void write(int b) 常规方法:规则跟之前一样,将指定的字节写出
public void println(Xxx xx) 特有方法:打印任意数据,自动刷新,自动换行
public void print(Xxx xx) 特有方法:打印任意数据,不换行
public void printf(String format, Object... args) 特有方法:带有占位符的打印语句,不换行
*/

public class PrintStreamDemo {
public static void main(String[] args) throws FileNotFoundException {
//1.创建字节打印流的对象
PrintStream ps = new PrintStream(new FileOutputStream("myio\\a.txt"), true, Charset.forName("UTF-8"));
//2.写出数据
ps.println(97);//写出 + 自动刷新 + 自动换行
ps.print(true);
ps.println();
ps.printf("%s爱上了%s","阿珍","阿强");
//3.释放资源
ps.close();
}
}

// 改变打印流向
// 调用系统的打印流,控制台直接输出97
System.out.println(97);
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
System.out.println(97);


// 字符打印流 PrintWriter
PrintWriter pw = new PrintWriter(new FileWriter("myio\\a.txt"),true);
//2.写出数据
pw.println("测试1");
pw.print("测试2");
pw.printf("测试3");
//3.释放资源
pw.close();

压缩流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import java.io.*;
import java.nio.file.*;
import java.util.zip.*;

public class ZipUtil {
/** 1. 解压:遍历条目 → 目录就建目录,文件就拷贝字节 */
public static void unzip(File src, File dest) throws IOException {
try (ZipInputStream zip = new ZipInputStream(new FileInputStream(src))) {
ZipEntry entry;
while ((entry = zip.getNextEntry()) != null) {
File out = new File(dest, entry.getName());
if (entry.isDirectory()) {
out.mkdirs(); // 条目本身是目录
} else {
out.getParentFile().mkdirs(); // 先保证父目录存在
Files.copy(zip, out.toPath(), // 流 → 文件,一行搞定
StandardCopyOption.REPLACE_EXISTING);
}
}
}
}

/** 2. 压缩单个文件:文件名作为条目名 */
public static void zipFile(File src, File destZip) throws IOException {
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(destZip));
FileInputStream fis = new FileInputStream(src)) {
zos.putNextEntry(new ZipEntry(src.getName()));
fis.transferTo(zos);
zos.closeEntry();
}
}

/** 3. 压缩文件夹:以源文件夹名作为顶层目录,递归写入 */
public static void zipDir(File src, File destZip) throws IOException {
try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(destZip))) {
addToZip(src, zos, src.getName());
}
}

/** 递归辅助:文件 → 直接写条目;目录 → 拼路径继续递归 */
private static void addToZip(File dir, ZipOutputStream zos, String name) throws IOException {
File[] files = dir.listFiles();
if (files == null) return;
for (File file : files) {
String entryName = name + "/" + file.getName();
if (file.isFile()) {
zos.putNextEntry(new ZipEntry(entryName));
try (FileInputStream fis = new FileInputStream(file)) {
fis.transferTo(zos);
}
zos.closeEntry();
} else {
addToZip(file, zos, entryName);
}
}
}

public static void main(String[] args) throws IOException {
unzip(new File("D:/aaa.zip"), new File("D:/out"));
zipFile(new File("D:/a.txt"), new File("D:/a.zip"));

// 压缩包生成在源文件夹同级目录:D:/aaa.zip
File src = new File("D:/aaa");
zipDir(src, new File(src.getParentFile(), src.getName() + ".zip"));
}
}

工具包

Commons-io、hutool

使用方式:

1,新建lib文件夹

2,把第三方jar包粘贴到文件夹中

3,右键点击 add as a library


多线程

  • 并行:在同一时刻,有多个指令在多个CPU上同时执行。
  • 并发:在同一时刻,有多个指令在单个CPU上交替执行。

实现多线程方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// 继承Thread类
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(i);
}
}
}
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
}
}

// Runnable 接口
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象,把MyRunnable对象作为构造方法的参数
//Thread(Runnable target)
// Thread t1 = new Thread(my);
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"坦克");
t1.start();
}
}

// 实现Callable接口
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println("跟女孩表白" + i);
}
//返回值就表示线程运行完毕之后的结果
return "答应";
}
}
public class Demo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
MyCallable mc = new MyCallable();
//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
FutureTask<String> ft = new FutureTask<>(mc);
//创建线程对象
Thread t1 = new Thread(ft);
//开启线程
t1.start();
String s = ft.get();
System.out.println(s);
}
}

/*
实现Runnable、Callable接口
好处: 扩展性强,实现该接口的同时还可以继承其他的类
缺点: 编程相对复杂,不能直接使用Thread类中的方法
继承Thread类
好处: 编程比较简单,可以直接使用Thread类中的方法
缺点: 可以扩展性较差,不能再继承其他的类
*/

设置和获取线程名称

1
2
3
4
5
/*
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称
Thread currentThread() 返回对当前正在执行的线程对象的引用
*/

常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class MyThreadNotes extends Thread {
// ================= 1. 名称操作 (图中红框高亮) =================
String name = getName(); // 返回此线程的名称,如果没设置名字默认名字 Thread-X(X序号,从0开始的)
setName("我的线程"); // 设置线程的名字(构造方法也可以设置名字)

// ================= 2. 静态方法 (通过 Thread. 调用) =================
Thread t = Thread.currentThread(); // 获取当前线程的对象
Thread.sleep(1000); // 让线程休眠指定的时间,单位为毫秒(哪条线程执行到这个方法,那么哪条线程就会在这里停留对应的时间)
Thread.yield(); // 出让线程/礼让线程

// ================= 3. 优先级与守护线程 =================
setPriority(10); // 设置线程的优先级 (通常范围 1-10),默认值是 5
int p = getPriority(); // 获取线程的优先级
setDaemon(true); // 设置为守护线程(当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了,不是立即结束)

// ================= 4. 线程控制 =================
join(); // 插入线程/插队线程
// 注:图片中 join 写的是 public static void join(),但实际 Java API 中 join() 是实例方法,实际开发通常写为 t.join() 来等待 t 线程执行完毕。
}

线程同步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 同步代码块
public class SellTicket implements Runnable {
private int tickets = 100;
private Object obj = new Object();
@Override
public void run() {
while (true) {
// 锁对象必须是唯一的
synchronized (obj) { // 一般写:MyThread.class
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
}
}
}
}
}

// 同步方法:就是把synchronized关键字加到方法上
private static synchronized boolean synchronizedMthod() {}
/* 锁对象不能自己指定,非静态是 this,静态:当前字节码文件对象
注意:extends Thread 实现的同步方法,非静态是锁对象是 this,多个 new 出来的线程对象锁不同,不会互斥。
可以换成 implements Runnable 或者使用同步代码块实现
*/

Lock锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.itheima.a11threadsafe3;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyThread extends Thread{
static int ticket = 0;
static Lock lock = new ReentrantLock();
@Override
public void run() {
while(true){
lock.lock();
try {
if(ticket == 100){
break;
}else{
Thread.sleep(10);
ticket++;
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}

死锁

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源,导致这些线程处于等待状态,无法前往执行

什么情况下会产生死锁:1.资源有限 2.同步嵌套

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Demo {
public static void main(String[] args) {
Object objA = new Object();
Object objB = new Object();
new Thread(()->{
while(true){
synchronized (objA){
//线程一
synchronized (objB){
System.out.println("小康同学正在走路");
}
}
}
}).start();
new Thread(()->{
while(true){
synchronized (objB){
//线程二
synchronized (objA){
System.out.println("小薇同学正在走路");
}
}
}
}).start();
}
}

生产者消费者

方法名 说明
void wait() 导致当前线程等待,直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify() 唤醒正在等待对象监视器的单个线程
void notifyAll() 唤醒正在等待对象监视器的所有线程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
public class Desk {
//定义一个标记
//true 就表示桌子上有汉堡包的,此时允许吃货执行
//false 就表示桌子上没有汉堡包的,此时允许厨师执行
public static boolean flag = false;
//汉堡包的总数量
public static int count = 10;
//锁对象
public static final Object lock = new Object();
}

public class Cooker extends Thread {
@Override
public void run() {
while(true){
synchronized (Desk.lock){
if(Desk.count == 0){
break;
}else{
if(!Desk.flag){
//生产
System.out.println("厨师正在生产汉堡包");
Desk.flag = true;
Desk.lock.notifyAll();
}else{
try {
Desk.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}

public class Foodie extends Thread {
@Override
public void run() {
while(true){
synchronized (Desk.lock){
if(Desk.count == 0){
break;
}else{
if(Desk.flag){
//有
System.out.println("吃货在吃汉堡包");
Desk.flag = false;
Desk.lock.notifyAll();
Desk.count--;
}else{
//没有就等待
//使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
try {
Desk.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}

public class Demo {
public static void main(String[] args) {
/*消费者步骤:
1,判断桌子上是否有汉堡包。
2,如果没有就等待。
3,如果有就开吃
4,吃完之后,桌子上的汉堡包就没有了
叫醒等待的生产者继续生产
汉堡包的总数量减一*/

/*生产者步骤:
1,判断桌子上是否有汉堡包
如果有就等待,如果没有才生产。
2,把汉堡包放在桌子上。
3,叫醒等待的消费者开吃。*/
Foodie f = new Foodie();
Cooker c = new Cooker();
f.start();
c.start();
}
}

阻塞队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
/*常见BlockingQueue:
ArrayBlockingQueue: 底层是数组,有界
LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

BlockingQueue的核心方法:
put(anObject): 将参数放入队列,如果放不进去会阻塞
take(): 取出第一个数据,取不到会阻塞
*/

public class Cooker extends Thread {
private ArrayBlockingQueue<String> bd;
public Cooker(ArrayBlockingQueue<String> bd) {
this.bd = bd;
}
@Override
public void run() {
while (true) {
try {
bd.put("汉堡包");
System.out.println("厨师放入一个汉堡包");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

public class Foodie extends Thread {
private ArrayBlockingQueue<String> bd;
public Foodie(ArrayBlockingQueue<String> bd) {
this.bd = bd;
}

@Override
public void run() {
while (true) {
try {
String take = bd.take();
System.out.println("吃货将" + take + "拿出来吃了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}

public class Demo {
public static void main(String[] args) {
ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
Foodie f = new Foodie(bd);
Cooker c = new Cooker(bd);
f.start();
c.start();
}
}

线程池

线程池是线程复用与任务调度机制,通过预先管理一组工作线程和任务队列,避免频繁创建、销毁线程,并控制并发规模。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
public static ExecutorService newCachedThreadPool() 创建一个没有上限的线程池
public static ExecutorService newFixedThreadPool (int nThreads) 创建有上限的线程池
*/

//1.获取线程池对象
ExecutorService pool1 = Executors.newFixedThreadPool(3);
//2.提交任务
pool1.submit(new MyRunnable());
pool1.submit(new MyRunnable());
pool1.submit(new MyRunnable());
pool1.submit(new MyRunnable());
pool1.submit(new MyRunnable());
pool1.submit(new MyRunnable());
//3.销毁线程池
//pool1.shutdown();


// 自定义线程池
/*
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor
(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);
参数一:核心线程数量 不能小于0
参数二:最大线程数 不能小于0,最大数量 >= 核心线程数量
参数三:空闲线程最大存活时间 不能小于0
参数四:时间单位 用TimeUnit指定
参数五:任务队列 不能为null
参数六:创建线程工厂 不能为null
参数七:任务的拒绝策略 不能为null
*/
ThreadPoolExecutor pool = new ThreadPoolExecutor(
3,
6,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);

//向Java虚拟机返回可用处理器的数目
int count = Runtime.getRuntime().availableProcessors();
System.out.println(count);

网络编程

三要素:IP地址、端口、协议

IP地址

  • IPv4:32位(4字节)地址;用“点分十进制”表示,如 192.168.1.66,便于记忆和使用。

  • IPv6:128位地址,解决IP地址资源不足;分8组,每组16位,用十六进制表示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// InetAddress
public class InetAddressDemo {
public static void main(String[] args) throws UnknownHostException {
//InetAddress address = InetAddress.getByName("itheima");
InetAddress address = InetAddress.getByName("192.168.1.66");

//public String getHostName():获取此IP地址的主机名
String name = address.getHostName();
//public String getHostAddress():返回文本显示中的IP地址字符串
String ip = address.getHostAddress();

System.out.println("主机名:" + name);
System.out.println("IP地址:" + ip);
}
}

端口:用两个字节表示的整数,它的取值范围是065535。其中,01023之间的端口号用于一些知名的网络服务和应用,普通的应用程序需要使用1024以上的端口号

UDP协议:

  • 用户数据报协议(User Datagram Protocol)
  • UDP是面向无连接通信协议。速度快,有大小限制一次最多发送64K,数据不安全,易丢失数据

TCP协议:

  • 传输控制协议 (Transmission Control Protocol)
  • TCP是面向连接通信协议。速度慢,没有大小限制,数据安全。

UDP通信程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 发送数据
// 1.创建DatagramSocket对象(快递公司)
// 绑定端口,以后我们就是通过这个端口往外发送
// 空参:所有可用的端口中随机一个进行使用,有参:指定端口号进行绑定
DatagramSocket ds = new DatagramSocket();
// 2.打包数据
byte[] bytes = "你好!".getBytes();
DatagramPacket dp = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("127.0.0.1"), 10086);
// 3.发送数据
ds.send(dp);
// 4.释放资源
ds.close();

// 接受数据
//1.创建DatagramSocket对象(快递公司)
//在接收的时候,一定要绑定端口,而且绑定的端口一定要跟发送的端口保持一致
DatagramSocket ds = new DatagramSocket(10086);
//2.接收数据包
byte[] bytes = new byte[1024];
DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
//该方法是阻塞的,程序执行到这一步的时候,会在这里死等
//等发送端发送消息
ds.receive(dp);
//3.解析数据包
byte[] data = dp.getData();
int len = dp.getLength();
InetAddress address = dp.getAddress();
int port = dp.getPort();
System.out.println("接收到数据" + new String(data,0,len));
System.out.println("该数据是从" + address + "这台电脑中的" + port + "这个端口发出的");
//4.释放资源
ds.close();

// 组播发送端
MulticastSocket ms = new MulticastSocket(); //创建MulticastSocket对象
InetAddress address = InetAddress.getByName("224.0.0.1");
// 组播接收端
MulticastSocket ms = new MulticastSocket(10000);
//将将当前本机,添加到224.0.0.1的这一组当中
InetAddress address = InetAddress.getByName("224.0.0.1");
ms.joinGroup(address);

// 广播
DatagramSocket ds = new DatagramSocket();
// 固定 ip
InetAddress address = InetAddress.getByName("255.255.255.255");

TCP通信

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 发送数据
//1.创建Socket对象
// 细节:在创建对象的同时会连接服务端
// 如果连接不上,代码会报错
Socket socket = new Socket("127.0.0.1",10000);
//2.可以从连接通道中获取输出流
OutputStream os = socket.getOutputStream();
//写出数据
os.write("aaa".getBytes());
//3.释放资源
os.close();
socket.close();


//接收数据
//1.创建对象ServerSocker
ServerSocket ss = new ServerSocket(10000);
//2.监听客户端的链接
Socket socket = ss.accept();
//3.从连接通道中获取输入流读取数据
InputStream is = socket.getInputStream();
// 解决乱码:使用字符流
// BufferedReader b = new BufferedReader(new InputStreamReader(socket.getInputStream()));
int b;
while ((b = is.read()) != -1){
System.out.println((char) b);
}
//4.释放资源
socket.close();
ss.close();

反射

  • 利用反射创建的对象可以无视修饰符调用类里面的内容
  • 可以跟配置文件结合起来使用,把要创建的对象信息和方法写在配置文件中。(读取到什么类,就创建什么类的对象。读取到什么方法,就调用什么方法。此时当需求变更的时候不需要修改代码,只要修改配置文件即可)

获取字节码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//1.Class这个类里面的静态方法forName
//Class.forName("类的全类名"): 全类名 = 包名 + 类名
Class clazz1 = Class.forName("com.itheima.reflectdemo.Student");
//源代码阶段获取 --- 先把Student加载到内存中,再获取字节码文件的对象
//clazz 就表示Student这个类的字节码文件对象。
//就是当Student.class这个文件加载到内存之后,产生的字节码文件对象

//2.通过class属性获取
//类名.class
Class clazz2 = Student.class;
//因为class文件在硬盘中是唯一的,所以,当这个文件加载到内存之后产生的对象也是唯一的
System.out.println(clazz1 == clazz2);//true

//3.通过Student对象获取字节码文件对象
Student s = new Student();
Class clazz3 = s.getClass();
System.out.println(clazz1 == clazz2);//true
System.out.println(clazz2 == clazz3);//true

获取构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*
Constructor<?>[] getConstructors() 获得所有的构造(只能public修饰)
Constructor<?>[] getDeclaredConstructors() 获得所有的构造(包含private修饰)
Constructor getConstructor(Class<?>... parameterTypes) 获取指定构造(只能public修饰)
Constructor getDeclaredConstructor(Class<?>... parameterTypes) 获取指定构造(包含private修饰)
*/
public class ReflectDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
//1.获得整体(class字节码文件对象)
Class clazz = Class.forName("com.itheima.reflectdemo.Student");
//2.获取构造方法对象
//获取所有构造方法(public)
Constructor[] constructors1 = clazz.getConstructors();
for (Constructor constructor : constructors1) {}
//获取所有构造(带私有的)
Constructor[] constructors2 = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors2) {
System.out.println(constructor);
}
//获取指定的空参构造
Constructor con1 = clazz.getConstructor();
Constructor con2 = clazz.getConstructor(String.class,int.class);
//获取指定的构造(所有构造都可以获取到,包括public包括private)
Constructor con3 = clazz.getDeclaredConstructor();
//了解 System.out.println(con3 == con1);
//每一次获取构造方法对象的时候,都会新new一个。
Constructor con4 = clazz.getDeclaredConstructor(String.class);
}
}

// 获取权限修饰符(返回整数)
int modifiers = con4.getModifiers();
// 利用空参构造方法创建对象
Student stu = (Student) con.newInstance();
//临时修改构造方法的访问权限(暴力反射)
con.setAccessible(true);
//直接创建对象
Student stu = (Student) con.newInstance("zhangsan", 23);

获取成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/*
Field[] getFields() 返回所有成员变量对象的数组(只能拿public的)
Field[] getDeclaredFields() 返回所有成员变量对象的数组,存在就能拿到
Field getField(String name) 返回单个成员变量对象(只能拿public的)
Field getDeclaredField(String name) 返回单个成员变量对象,存在就能拿到

Field类中用于创建对象的方法
void set(Object obj, Object value):赋值
Object get(Object obj) 获取值
*/
//1.获取class字节码文件的对象
Class clazz = Class.forName("com.itheima.myreflect3.Student");
//2.获取所有的成员变量
/* Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}*/
//获取单个的成员变量
Field name = clazz.getDeclaredField("name");
//获取权限修饰符
int modifiers = name.getModifiers();
//获取成员变量的名字
String n = name.getName();
//获取成员变量的数据类型
Class<?> type = name.getType();
//获取成员变量记录的值
Student s = new Student("zhangsan",23,"男");
name.setAccessible(true);
String value = (String) name.get(s);
//修改对象里面记录的值
name.set(s,"lisi");

获取成员方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/*
Method[] getMethods() 返回所有成员方法对象的数组(只能拿public的)
Method[] getDeclaredMethods() 返回所有成员方法对象的数组,存在就能拿到
Method getMethod(String name, Class<?>... parameterTypes) 返回单个成员方法对象(只能拿public的)
Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回单个成员方法对象,存在就能拿到
*/
//1. 获取class字节码文件对象
Class clazz = Class.forName("com.itheima.myreflect4.Student");
//2. 获取里面所有的方法对象(包含父类中所有的公共方法)
Method[] methods = clazz.getMethods();
// 获取里面所有的方法对象(不能获取父类的,但是可以获取本类中私有的方法)
Method[] methods = clazz.getDeclaredMethods();
// 获取指定的单一方法
Method m = clazz.getDeclaredMethod("eat", String.class);
// 获取方法的修饰符
int modifiers = m.getModifiers();
// 获取方法的名字
String name = m.getName();
// 获取方法的形参
Parameter[] parameters = m.getParameters();
//获取方法的抛出的异常
Class[] exceptionTypes = m.getExceptionTypes();

/* 方法运行
Method类中用于创建对象的方法
Object invoke(Object obj, Object... args):运行方法
参数一:用obj对象调用该方法
参数二:调用方法的传递的参数(如果没有就不写)
返回值:方法的返回值(如果没有就不写)
*/
Student s = new Student();
m.setAccessible(true);
//参数一s:表示方法的调用者
//参数二"汉堡包":表示在调用方法的时候传递的实际参数
String result = (String) m.invoke(s, "汉堡包");

动态代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class ProxyUtil {
public static Star createProxy(BigStar bigStar){
/* java.lang.reflect.Proxy类:提供了为对象产生代理对象的方法:
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
参数一:用于指定用哪个类加载器,去加载生成的代理类
参数二:指定接口,这些接口用于指定生成的代理长什么,也就是有哪些方法
参数三:用来指定生成的代理对象要干什么事情*/
Star star = (Star) Proxy.newProxyInstance(
ProxyUtil.class.getClassLoader(),//参数一:用于指定用哪个类加载器,去加载生成的代理类
new Class[]{Star.class},//参数二:指定接口,这些接口用于指定生成的代理长什么,也就是有哪些方法
//参数三:用来指定生成的代理对象要干什么事情
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
/*
* 参数一:代理的对象
* 参数二:要运行的方法 sing
* 参数三:调用sing方法时,传递的实参
* */
if("sing".equals(method.getName())){
System.out.println("准备话筒,收钱");
}else if("dance".equals(method.getName())){
System.out.println("准备场地,收钱");
}
return method.invoke(bigStar,args);
}
}
);
return star;
}
}

BigStar bigStar = new BigStar("鸡哥");
Star proxy = ProxyUtil.createProxy(bigStar);
String result = proxy.sing("只因你太美");

日志

Logback 配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!--
CONSOLE :表示当前的日志信息是可以输出到控制台的。
-->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<!--输出流对象 默认 System.out 改为 System.err-->
<target>System.out</target>
<encoder>
<!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度
%msg:日志消息,%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %c [%thread] : %msg%n</pattern>
</encoder>
</appender>

<!-- File是输出的方向通向文件的 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
<charset>utf-8</charset>
</encoder>
<!--日志输出路径-->
<file>C:/code/itheima-data.log</file>
<!--指定日志文件拆分和压缩规则-->
<rollingPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!--通过指定压缩文件名称,来确定分割文件方式-->
<fileNamePattern>C:/code/itheima-data2-%d{yyyy-MMdd}.log%i.gz</fileNamePattern>
<!--文件拆分大小-->
<maxFileSize>1MB</maxFileSize>
</rollingPolicy>
</appender>

<!--
level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF
, 默认debug
<root>可以包含零个或多个<appender-ref>元素,标识这个输出位置将会被本日志级别控制。
-->
<root level="info">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="FILE" />
</root>
</configuration>

使用

1
2
3
4
5
6
public class Sample {
private static final Logger LOGGER = LoggerFactory.getLogger(Sample.class);
public static void main(String[] args){
LOGGER.info("A Message From LOGGER:{}", "Hello World");
}
}

类加载器

1
2
3
4
5
6
7
8
9
10
11
12
//获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
//获取系统类加载器的父加载器 --- 平台类加载器
ClassLoader classLoader1 = systemClassLoader.getParent();
//获取平台类加载器的父加载器 --- 启动类加载器
ClassLoader classLoader2 = classLoader1.getParent();

// public InputStream getResourceAsStream(String name)
// 利用加载器去加载一个指定的文件
InputStream is = systemClassLoader.getResourceAsStream("prop.properties"); Properties prop = new Properties();
prop.load(is);
is.close();

单元测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class JunitTest {
// 只能直接运行无参无返回值的非静态方法
@Test
public void method2Test() {}
}

public class JunitDemo3 {
//1.利用Before去对数据做一个初始化的动作
//2.利用Test真正的去测试方法
//3.利用After去还原数据

//需求:测试File类中的delete方法是否书写正确???
@Before
public void beforemethod() throws IOException {
//先备份
File src = new File("C:\\Users\\moon\\Desktop\\a.txt");
File dest = new File("C:\\Users\\moon\\Desktop\\copy.txt");
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
int b;
while((b = fis.read()) != -1){
fos.write(b);
}
fos.close();
fis.close();
}

//作为一个标准的测试人员,运行完单元测试之后,不能污染原数据
//需要达到下面两个要求:
//1.得到结果
//2.a.txt还在而且其他的备份文件消失
@Test
public void method(){
File file = new File("C:\\Users\\moon\\Desktop\\a.txt");
boolean delete = file.delete();
//检查a.txt是否存在
boolean exists = file.exists();
//只有同时满足了下面所有的断言,才表示delete方法编写正确
Assert.assertEquals("delete方法出错了",delete,true);
Assert.assertEquals("delete方法出错了",exists,false);
}

@After
public void aftermethod() throws IOException {
//还要对a.txt做一个还原
File src = new File("C:\\Users\\moon\\Desktop\\copy.txt");
File dest = new File("C:\\Users\\moon\\Desktop\\a.txt");
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
int b;
while((b = fis.read()) != -1){
fos.write(b);
}
fos.close();
fis.close();
//备份数据要删除
src.delete();
}
}

注解