首页  思维导图  详情

Java学习笔记

2021-08-29 14:15:46   0  举报





AI智能生成

补充API的笔记

模板活动合辑

学霸笔记

JVM

后端开发

自考笔记

笔记

作者其他创作

大纲/内容

异常

用增强for循环遍历TreeSet集合时出现的异常

ClassCastException

D:\Develop\jdk\jdk12\bin\java.exe "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2.4\lib\idea_rt.jar=55074:D:\Program Files\JetBrains\IntelliJ IDEA 2019.2.4\bin" -Dfile.encoding=UTF-8 -classpath E:\IdeaProjects\AdvancedCode\out\production\day09_heima_hash_set com.itheima.hashset.job.test02.Test01
Exception in thread "main" java.lang.ClassCastException: class com.itheima.hashset.job.test02.Employee cannot be cast to class java.lang.Comparable (com.itheima.hashset.job.test02.Employee is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')
at java.base/java.util.TreeMap.compare(TreeMap.java:1291)
at java.base/java.util.TreeMap.put(TreeMap.java:536)
at java.base/java.util.TreeSet.add(TreeSet.java:255)
at com.itheima.hashset.job.test02.Test01.main(Test01.java:25)

Process finished with exit code 1

原因分析

没有重写

一 . Java基础

day01_环境搭建&快速入门

环境搭建

Java语言的背景介绍

Java跨平台性

JDK和JRE关系

子主题

day02_类型转换&运算符

day03_siwtch和循环语句

day04_idea&数组

day05_方法

day06_进制

什么是进制

进制是指进位制,是人们规定的一种进位方式,表示某一位置上的数,运算时是逢X进一位.
十进制是逢十进一,二进制是逢二进一,八进制是逢八进一

常见的进制

二进制 0~1

逢二进一,借一当十

任意进制到十进制的转换公式: 系数*基数的权次幂相加 :
例1: 0b110 --> (0*2^0=0)+(1*2^1)+(1*2^2)=6
例2: 0x110 --> (0*16^0=0)+(1*16^1)+(1*16^2)=272

以 0b开头

八进制 0~7

以0开头

十进制

运算规则:逢十进一,借一当十

十六进制0~7

以0x开头

原码反码补码

计算机中的数据都是以二进制补码的形式在运算,而补码则是通过反码和原码推算出开的

原码:看数据用的

反码:转数据用的

补码:运算数据用的

位运算

位与

取反

位移运算符

<<有符号左移运算

二进制位向左移动,左边符号位丢弃,右边补齐0

运算规则

向左移动几位,就是乘以2的几次幂

>>有符号右移运算

二进制位向右移动,使用符号位进行补位

运算规则

向右移动几位,就是除以2的几次幂

>>> 无符号右移运算

无论符号位是0还是1,都补0

day07_Debug和二维数组

day01_面向对象基础

System类

常见方法

day01_String 和 StringBuffer 和 StringBuilder 类

String

属性

Prototype

length

静态方法

fromCharCode(...Num)

fromCodePoint(...Num) -- 无效字符返回错误

常用方法

equals(String srt)

比较字符串的内容是否相等

equalsIgnoreCase()

比较两个字符串的内容是否相等,忽略大小写

charAt(int index);

返回输入的索引处的字符,索引从0开始

length();

返回字符串的长度

toCharArray();

将当前字符串拆分为字符数组并返回

substring(int index);

字符串的截取,从index索引处开始截取,直到末尾

substring(int starIndex,int endIndex);

从statindex索引位置开始截取到endindex处(不包含endindex)

replace("旧值" , "新值");

将旧值替换为新值,返回新的字符串(用于敏感词屏蔽)

String[] split = str.split(",");

根据 "," 切割字符串,返回一个数组

原型方法

anchor(name)

返回一个ahtml元素

charAt(index)

返回指定索性的字符串

charCodeAt(index)

返回指定索性的字符串的Unicode编码

concat(String)

返回字符串的拼接 -- 'a'.concat('b') ==> 'ab'

endsWith(String, [index结束位置])

判断指定字符串为目标字符串的结束为止，可指定结束值

includes(String,[index截至位置]

判断指定字符串是否存在目标字符串，可指定搜索位置

indexOf(String)

返回字符串是否存在目标字符串，存在返回位置，不存在返回-1

lastIndexOf(String)

返回字符串是否存在目标字符串的结束为止，不存在返回-1

link(url)

创建一个a标签

match(正则)

返回匹配符合正则规则的字符串

replace( 正则|String newSubStr|function )

search(正则）

返回匹配成功的首位索引。无返回-1

slice(start,End)

返回提取后的字符串，Start开始位置（如为-1表示length-1）,end为结束位置，不传为length-1

split('分割’|正则，返回数量)

返回字符串的分割，带返回数量为返回指定数量的数组

startsWith('字符串‘, 起始位置)

查看字符串是否在起始位置，默认为0

substr(开始位置，截至位置)

提取字符串，开始位置默认为0(负数为length-值)，截至默认为length(不包含)

substring(开始位置，截至位置)

提取字符串，开始位置默认为0(负数为length-值)，截至默认为length(不包含)

toLowerCase()

返回字符串小写

toLocaleLowerCase()

返回字符串小写（针对特殊地区）

toUpperCase()

返回字符串大写

toLocaleUpperCase()

返回字符串的大写（针对特殊地区）

toString(String)

返回字符串形式

trim()

删除字符串两边的空格

StringBuilder
可变字符串

构造方法

StringBuilder sb = new StringBuilder();

创建一个空白可变字符串对象,不包含任何内容

StringBuilder sb = new StringBuilder("abc");

根据字符串的内容,来创建可变字符串对象

常用方法

sb.append(任意类型);

添加数据,返回对象本身

StringBuilder reverse = sb.reverse();

返回相反的字符序列

int length = sb.length();

返回长度(字符出现的个数)

String s = sb.toString();

将StringBuilder对象转换为String对象

作用

提高字符串的操作效率

StringBuffer

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder是一个可变字符串类,我们可以把它看成是一个容器

day01_ArrayList集合&综合案例

学生管理系统

分析

定义一个学生类

学生类

成员变量

构造方法

成员方法

主界面的代码实现

添加学生的代码实现

查看学生的代码实现

删除学生的代码实现

修改学生的代码实现

设计

编程

二 . JavaSE基础进阶

day01_

分类思想

分类思想的介绍

黑马信息管理系统分类

标准学生类,封装键盘录入的学生信息(id,name,age,birthday)

StudentDao类Dao: (Data Access Object)用于访问存储数据的数组或集合

StudentService类: 用来进行业务逻辑的处理(例如:判断录入的id时候存在)

StudentController类和用户打交道(接收用户需求,采集用户信息,打印数据到控制台)

分类思想
分工协作,专人干专事.

分包思想

包的概述

包的注意事项

类与类之间的访问

黑马信息管理系统

学生管理

老师管理

day02_继承

day03_封装

day04_多态

day05

API 应用程序编程接口
(Application Programming Interface)

简单来说:就是Java帮我们写好的一些方法,我们直接拿过来用就可以了

API文档

常用的类

Math

没有构造方法,所有的方法都是静态的,直接通过类名.调用

常用类

返回参数的绝对值

abs(int a);

向上取整

ceil(double b);

向下取整

floor(double b);

四舍五入

round(float a);

返回两个int值中的较大值

max(int a, int b);

返回两个int值中的较小值

min(int a, int b);

返回b的次幂的值

pow(double a, double b);

返回值为double的正值[0.1,1.0)

random();

System

常用方法

exit(int status);

终止当前运行的Java虚拟机,零为正常停止,非零表示异常终止

System.currentTimeMillis();

获取1970年1月1日0时0分0秒到当前时间经历过的毫秒值

arraycopy(数据源数组 , 起始索引, 目标数组 , 起始索引 ,拷贝个数);

数组拷贝

Object

概述

每一个类都可以将Object作为父类. 所有类都直接或者间接的继承自该类.

构造方法:

public Object();

Objects

常用方法

toString(对象);

返回参数中对象的字符串表示形式

toString(对象, 默认字符串);

返回对象的字符串表示形式

isNull(对象);

判断对象是否为空

noNull(对象);

判断对象是否不为空

时间类

BigDecimal
(用于高精度计算)

构造方法

BigDecimal(double val)

参数为: double

BigDecimal(String val)

参数为: String

如果想要进行精确运算,使用字符串的构造

常用方法

四则运算

加法

BigDecimal add(另一个BigDecimal对象);

减法

BigDcimal subtract(另一个BigDecimal对象);

乘法

BigDcimal multiply(另一个BigDecimal对象);

除法

BigDcimal divide(另一个BigDecimal对象);

BigDcimal subtract(另一个BigDecimal对象,精确几位, 舍入模式);

包装类

基本类型的包装类

byte----Byte

short----Short

int----Integer

Integer
类

常用方法

获取int的最大值

Integer.MAX_VALUE

获取int的最小值

Integer.MIN_VALUE

Integer.valueOf(String str);

Integer.valueOf(int i)

子主题

long----Long

float----Float

double----Double

char----Character

boolean----Boolean

自动装箱和自动拆箱

包装类的数据转换

数组的高级操作

二分查找

冒泡排序

Arrays
数组工具类

子主题

day06_

day01_

day09_红黑树、HashSet、Map

集合框架

Collection接口

方法

boolean add(E element)

Iterator iterator()

int size()

boolean isEmpty()

boolean contains(Object obj)

boolean containsAll(Collection c)

boolean addAll(Collection from)

boolean remove(Object obj)

boolean removeAll(Collection c)

void clear()

boolean retainAll(Collection c)：删除所有与c集合中的元素不同的元素

Object[] toArray()

T[] toArray(T[] arrayToFill)

子类

List接口

ArrayList：动态列表

LinkedList：可以在任何位置进行高效插

List.of(元素1,元素2....); 这个方法底层会给你创建一个List接口的实现类对象，但是呢，这个对象既不是ArrayList也不是LInkedList;
但是给你返回的List集合是一个不可变的集合

Deque接口

方法

void addFirst(E item)

void addLast(E item)

boolean offerFirst(E item)

boolean offerLast(E item)

E removeFirst()

E removeLast()

E pollFirst()

E pollLast()

E getFirst()

E getLast()

E peekFirst()

E peekLast()

子类

ArrayDeque：双端队列

Queue接口

方法

boolean add(E item)

boolean offer(E item)

E remove()

E poll()

E element()

E peek()

子类

PriorityQueue：优化级队列

Set接口

HashSet：没有重复元素的无序集合

TreeSet：没有重复元素的有序集合

EnumSet：包含枚举类型值的集合

LinkedHashSet：可以记住元素插入顺序的集合

SortedSet

E first()：返回集合中最小的元素

E last()：返回集合中最大的元素

NavigableSet

E higher(E value)

E lower(E value)

E ceiling(E value)

E floor(E value)

E pollFirst()

E pollLast()

Map接口

Map.Entry 静态内部类

K getKey()

V getValue()

V setValue(V newValue)

方法

Set keySet()

Collection values()

Set> entrySet()

V get(Object key)

V put(K key, V value) :向map集合中添加键值对

map集合变量.get(K hey); 根据键获取map集合中的值

String ls = map.remove("2号丈夫"); 根据键删除键对应的值,返回的是,删除的值

map.keySet();获取所有的键,返回存储Set的集合

void putAll(Map entries)

boolean containsKey(Object key)

boolean containsValue(Object value)

子类

HashMap：存储键值关联的数据结构

TreeMap：键值有序排列的映射表

EnumMap：键值属于枚举类型的映射表

LinkedHashMap：可以记住键值添加顺序的映射表

SortedMap

K firstKey()：返回最小元素

K lastKey()：返回最大元素

WeakHashMap：如果值以后不再被使用则可以被GC回收的映射表

IdentityHashMap：用 == 而不是equals比较键值的映射表

iterator接口

E next()

boolean hasNext()

void remove()

排序

Comparable接口

作用：让一个类实现此接口，那么这个类的集合就具有了排序功能

方法

int compareTo(T other)

Comparator接口

作用：让一个类实现此接口，这个类可以根据自己的定义的属性灵活的进行排序

方法

int compare(T a, T b)

Collections工具类

void sort(List items)：对列表中的元素排序

void sort(List items, Comparator c)：对列表中的元素排序

void shuffle(List items)：随机地打乱列表中的元素

void shuffle(List items, Random r)：随机地打乱列表中的元素

void reverse(List items)：逆转列表中元素的顺序

Comparator reverseOrder()：返回一个比较器

Comparator reverseOrder(Comparator c)：返回一个比较器

T min(Collection items)

T max(Collection items)

T min(Collection items, Comparator c)

T max(Collection items, Comparator c)

void copy(List to, List from)

void fill(List l, T value)

boolean addAll(Collection items, T... values)

boolean replaceAll(List items, T oldValue, T newValue)

int frequency(Collection items, Object o)：返回列表中与对象o相同的元素个数

boolean disjoint(Collection c1, Collection c2)：如果两个集合没有共同的元素，则返回true

Collection synchronizedCollection(CollectionM c)

List synchronizedList(List c)

Set synchronizedSet(Set c)

SortedSet synchronizedSortedSet(SortedSet c)

Map synchronizedMap(Map map)

SortedMap synchronizedSortedMap(SortedMap map)

Arrays工具类

List asList(E... array)：返回一个数组元素的列表视图。

可变参数

可变参数用在方法的形式参数的位置，它可以看做是一个数组，可以接收多个实际参数。

public static void main(String[] args){
    int sum1=getSum(3,4,5); //求3,4,5的和

    int sum2=getSum(1,2,3,4,5,6); //求1,2,3,4,5,65的和

    int[] array={1,2,3,4,5,6};
    int sum2=getSum(array); //求1,2,3,4,5,65的和
}

//求任意几个数的和
//int... array ：可变参数，可以接收多个int类型的值
public static int getSum(int... array){
    int sum=0;
    for(int i=0;i<array.length;i++){
        sum+=array[i];
    }
    return sum;
}

可变参数的运用

子主题

Stream(流)

流程

获取流

单列集合获取流

Stream<元素类型> strem = 集合对象.stream();

单列集合获取流，直接使用集合对象调用stream()方法即可;

双列集合获取流

双列集合获取流，不能够直接获取，把双列集合转换为单列集合；

//键集，获取流
Stream<键的类型> keyStream=map.keySet().stream();

//值集，获取流
Stream<值的类型> valueStream=map.values().stream();

//键值对集，获取流
Stream<Map.Entry> entryStream=map.entrySet().stream();

数组获取流、同一个类型的多个数据获取流

Integer[] array={1,2,3,4,5};
Stream<元素类型> arrayStream1=Stream.of(array);
Stream<元素类型> arrayStream2=Stream.of(1,2,3,4,5);

中间操作

对Stream流进行中间操作，返回值也是一个Stream流。

fliter: 对元素进行过滤

limit: 截取前面n个元素

skip: 跳过前面n个元素

map: 对流中的元素类型进行转换

concat: 把两个流合并为1个流
  Stream<Integer> stream1=List.of(1,2,3,4).stream();
  Stream<Integer> stream2=List.of(5,6,7,8).stream();

举例：把stream1和stream2合并为1个流
  Stream stream3=Stream.concat(stream1,stram2)

终结操作

forEach: 遍历元素

count: 统计个数

collect: 收集剩余的元素到新的集合

toList：把元素放到List集合中

toSet: 把元素放到Set集合中

toMap: 把元素放到Map集合
需要给定2个Lambda表达式，分别表示键和值

例题

Stream流练习

ArrayList<Student> list=new ArrayList<>();
list.add(new Student("张三",20));
list.add(new Student("李四",18));
list.add(new Student("王五",19));
list.add(new Student("赵六",25));
list.add(new Student("前妻",27));
list.add(new Student("王炸",28));
list.add(new Student("小王",26));
list.add(new Student("大王",24));
list.add(new Student("蘑菇头",23));
list.add(new Student("妹爷",29));
list.add(new Student("老王",30));
list.add(new Student("老李",22));

//演示Stream流的过滤、跳过、截取、转换、遍历功能
list.stream()
    .filter(s -> s.getAge() > 20)  //过滤年龄>20的学生
    .skip(2) //跳过前面2个
    .limit(4) //截取前面4个
    .map(s -> s.getName()) //把Student元素转换为String姓名
    .forEach(s -> System.out.println(s)); //遍历输出

System.out.println("-----------------");

//演示Stream流的过滤、跳过、截取、最后收集成List的功能
List<Student> list1 = list.stream()
                .filter(s -> s.getAge() > 20)  //过滤年龄>20的学生
                .skip(2) //跳过前面2个
                .limit(4) //截取前面4个
                .collect(Collectors.toList()); //把剩余的元素收集成List集合
System.out.println(list1);

System.out.println("-----------------");
//演示Stream流的过滤、跳过、截取、最后收集成Map的功能
Map<String,Integer> map=list.stream()
    .filter(s -> s.getAge() > 20)  //过滤年龄>20的学生
    .skip(2) //跳过前面2个
    .limit(4) //截取前面4个
    .collect(Collectors.toMap(
        s -> s.getName(),
        s -> s.getAge())
     ); //把剩余的元素收集为Map集合
System.out.println(map);

package com.itheima.job.test02;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
* @Auther: YeJunli
* @Date: 2021/8/26 - 08 - 26 - 22:22
* @Description:
* @version: 1.0
*/
public class Test02 {
    public static void main(String[] args) {
//        二、按要求完成下面的需求：
//        1.定义一个字符串数组
//        String[] arr = {"123","456","777","345","345","222","999","222","110","120","567"};
//
//        2.通过数组获取流，把数组中的元素转换为Integer类型
//        提示：这里可以用map方法
//        3.截取前面6个
//        4.跳过前面3个
//        5.去除重复元素
//        6.把元素收集成List集合
//        7.遍历打印集合中的元素       String[] arr = {"123","456","777","345","345","222","999","222","110","120","567"};

        String[] arr = {"123", "456", "777", "345", "345", "222", "999", "222", "110", "120", "567"};

//        2.通过数组获取流，把数组中的元素转换为Integer类型
        List<Integer> collect = Arrays.stream(arr)

                //对流中的元素类型进行转换
                .map(s -> Integer.parseInt(s))

                // 截取流中的前6个数据
                .limit(6)

                // 跳过流中的前3个数据
                .skip(3)

                //去除重复数据
                .distinct()

                //收集剩余的元素,返回一个新集合
                .collect(Collectors.toList());

        //遍历新集合
        collect.forEach(integer -> System.out.println(integer));

    }
}

子主题

练习题

package com.itheima.job.test01;

/**
* @Auther: YeJunli
* @Date: 2021/8/26 - 08 - 26 - 21:01
* @Description:
* @version: 1.0
*/
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 void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

day01_File 和 IO流

File类
表示文件或者文件夹的路径

创建File类对象的方式

创建File对象时，需要指定一个路径。这个路径可以存在，也可以不存在，可以是文件路径也可是文件夹路径。

File f1=new File("C:\\a.txt");
System.out.println(f1);

File f2=new File("C:\\itheima\\aaa","a.txt");
System.out.println(f2);

File dir=new File("C:\\itheima\\aaa");
File f3=new File(dir,"a.txt");
System.out.println(f3);

File类创建功能

方法名

boolean newFile = dir.createNewFile();

如果文件存在,那么创建失败,返回false

如果文件不存在,那么创建成功,返回true

不管调用者有没有后缀名,只能创建文件

文件所在的文件夹必须存在

boolean mkdir = dir.mkdir();

只能创建单级文件夹,不能创建多级文件夹

不管调用者有没有后缀名,只能创建单级文件夹

boolean mkdirs = dir.mkdirs();

可以创建单级文件夹,也可以创建多级文件夹

不管调用者有没有后缀名,只能创建文件夹

路径

绝对路径

绝对路径：从盘符开始的路径
绝对路径 C:\\IdeaProjects\javase\myModule\a.txt

File file1 = new File("E:\\IdeaProjects\\AdvancedCode\\day11_heima_IOStream\\src\\test01\\a.txt");

相对路径

相对路径：相对于项目的根目录，下面的路径
//假设项目的根路径是C:\\IdeaProjects\javase
相对路径：myModule\a.txt

File dir = new File("day11_heima_IOStream\\src\\test01\\a.txt");

File类删除功能

boolean delete = dir.delete();

删除后不能在回收站找回

如果是删除的是文件,那么直接删除,
如果删除的是文件夹,那么只能删除空文件夹

如何要删除一个有内容的文件夹,只能先进入到这个文件夹,
把里面的内容全部删除完毕,才能再次删除这个文件夹

File类的常用方法

创建

public boolean mkdir()
创建文件夹

public boolean mkdirs()
创建多级文件夹(推荐)

public boolean createNewFile()
创建文件

删除

public void delete()
删除文件或者文件夹（必须是空的文件夹才能删除）

判断

public boolean exists()
判断File对象的路径是否存在

boolean exists = file.exists();

public boolean isDirectory()
判断File对象的路径是否为文件夹路径

boolean directory = file.isDirectory();

public boolean isFile()
判断File对象的路径是否为文件路径

boolean file1 = file.isFile();

获取

public String getName()
获取文件或者文件夹的名称

返回由此抽象路径名表示的文件或目录的名称

如果调用者是文件,那么获取的是文件名和后缀名

如果调用者是一个文件夹,那么获取的是文件夹的名字

public String getParent()
获取文件或者文件夹的父目录，返回字符串

public File getParentFile()
获取文件或者文件夹的父目录，返回File对象

public String getPath()
获取File对象封装的路径

public String getAbsolutePath()
获取绝对路径, 返回值是String类型

public File getAbsoluteFile()
获取绝对路径，返回值File对象

public long length()
获取文件的大小，单位(字节)
不能获取文件夹的长度

获取

File dir = new File("day11_heima_IOStream\\src\\test01\\a.txt");

        //获取文件名
        System.out.println(dir.getName());

        //获取File对象中的文件的路径
        System.out.println(dir.getParent());

        //获取父绝对路径
        System.out.println(dir.getAbsolutePath());

        //获取File对象的封装路径
        System.out.println(dir.getPath());

        long length = dir.length();
        System.out.println("获取文件的大小(字节):"+length);
//数字和英文字母占1个字节,中文字母占3个字节

遍历文件夹的方法

public File[]  listFiles()
    获取当前目录下所有文件和文件夹，把获取到文件和文件夹以File对象的方式存在File数组中。
    注意：
     1.返回值是null的几种情况
            File对象的目录路径不存在
            File对象的路径为文件路径
            File对象的文件没有权限访问

        2.File对象的目录存在，但是目录中没有东西
         返回值是一个File[],但是数组中没有元素

File类中的高级获取功能

File[] files = file.listFiles();

进入文件夹,获取这个文件夹里面所有的文件和文件夹的File对象,
并把这些File对象都放在一个数组中返回,包括隐藏文件和隐藏文件夹都可以获取

注意事项:

当调用者不存在时

返回null

当调用者是一个文件时

返回为null

当调用者时一个空文件夹时

返回一个长度为0的数组

当调用者是一个有内容的文件夹时

将文件夹内的全部File对象返回

当调用者是一个有权限才能进入的文件夹时

返回null

练习

删除一个多级文件夹及文件

思路

先删除这个文件夹里面的所有文件内容

递归方法,在方法体中调用自己

注意:

可以解决所有文件夹里面所有内容的File对象

步骤

进入------得到file文件夹里面所有内容的File对象

遍历

判断

如果遍历得到的File对象是文件,就删除

判断

递归

删除自己

File对象的常见方法

操作

删除文件夹

思路

删除文件夹的思路：先删除里面的内容，然后再删除外面空的文件夹

IO流

什么是io流

IO流是用来处理数据的输入（读）和输出（写）的。

IO可以对硬盘中的文件进行读写

IO流所做的事情就是对文件的读和写的操作

IO流分为输入流和输出流，输入流：读取数据；输出流：写入数据

把大脑当作内存,把纸当作硬盘

输入

把你脑子里所想的事情，写在纸上，这个过程叫输出；

输出

这里有一本小说，你把书本上的问题读取到大脑里，这个过程叫输入；

分类

按流向

输入流：读数据

输出流：写数据

按照读写的数据类型分类

字节流：读写任意类型的文件（图片、视频、文字、游戏...）

字节输入流：InputStream，用来读取字节数据

- FileInputStream：读取文件中的字节
- BufferedInputStream: 对已有的InputStream进行包装，提高读取的效率

字节输出流：OutputStream，用来写字节数据

FileOutputStream fos= new FileOutputStream("test01\\b.txt");

如果文件不存在,会帮我们创建

如果文件存在,会清空文件

fos.write(97)

向硬盘中的b.txt文件写入数据(a)

换行

fos.write("\r\n".getBytes());

Windows换行

Linux换行

Mac换行

写数据,进行追加

FileOutputStream outStr = new FileOutputStream("test01\\b.txt",true);

- FileOutputStream：写入文件中的字节
- BufferedOutputStream：对已有的OutputStream进行包装，提高写入的效率

字符流

读写文本文件（用记事本打开，能看懂的就是文本文件）

包括Java文件,txt文件等

字符输入流: Reader

- FileReader
- BufferedReader

字符输出流: Writer

- FileWriter
- BufferedWriter

学习IO流的步骤

1.创建流对象(搭桥)

2.读写数据(过桥)

3.释放资源(过河拆桥)

字节流写数据

//创建输出流对象(搭桥)，需要关联一个文件
//如果文件不存在，会自动创建一个
//如果文件存在，会把原来的文件覆盖掉。
FileOutputStream fos=new FileOutputStream("myModule11\\a.txt");

//写数据(过桥)
fos.write("helloworld".getBytes());
fos.write("\r\n".getBytes()); //写一个换行
fos.write("你好世界".getBytes());

//写单个字节
fos.write(97); //97对应字符'a'

//写多个字节
byte[] bs={97,98,99,100,101}; //'a','b','c','d','e'

//字节数组的一部分
fos.write(bs,0,3);

//释放资源(过河拆桥)
fos.close();

字节流读数据

//1.创建输入流对象
FileInputStream fis=new FileInputStream("myModule11\\a.txt");

//2.读取数据：  一次读多个字节
byte[] bs=new byte[1024];
int len ; //记录每次读取的字节个数
while ((len=fis.read(bs))!=-1){
    //把读取到的有效字节个数，转换为字符串
    String str=new String(bs,0,len);
    System.out.println(str);
}

//3.释放资源
fis.close();

IO流重点掌握知识点

普通流文件复制

需求：把a.txt文件中的内容，复制到b.txt文件中

一次复制一个字节

//1.创建输入、输出流对象
FileInputStream fis = new FileInputStream("day11/a.txt");
FileOutStream fos = new FileOutStream("day11/b.txt");

//2.一边读一边写
int b; //记录每次读取的一个字节
while((b=fis.read())!=-1){
fos.write(b);
}

//3.关闭流
fos.close();
fis.close();

一次复制多个字节【重点】

//1.创建输入、输出流对象
FileInputStream fis = new FileInputStream("day11/a.txt");
FileOutStream fos = new FileOutStream("day11/b.txt");

//2.一边读一边写
byte[] bs = new byte[1024];
int count; //记录每次读取的字节有效个数
while((count=fis.read(bs))!=-1){
fos.write(bs,0,count);
}

//3.关闭流
fos.close();
fis.close();

字节流复制文件【重点】

把a.txt文件中的内容，复制到b.txt文件中

文件复制的思路：
使用输入流，读取源文件(a.txt)
    使用输出流，写入目标文件(b.txt)

//使用输入流，读取源文件(a.txt)
FileInputStream fis=new FileInputStream("myModule11\\itheima42.jpg");
//使用输出流，写入目标文件(b.txt)
FileOutputStream fos=new FileOutputStream("myModule11\\itheima43.jpg");

//一遍读，一遍写
byte[] bs=new byte[1024];
int len; //每次读取的有效个数
while ((len=fis.read(bs))!=-1){
    //把读取到有效字节，写入目标文件中
    fos.write(bs,0,len);
}

//释放资源
fos.close();
fis.close();

缓冲流文件复制

一次复制一个字节

//1.创建缓冲输入、输出流对象
BufferedInputStream bis =
    new BufferedInputStream(new FileInputStream("day11/a.txt"));

BufferedOutputStream bos =
    new BufferedOutputStream(new FileOutputStream("day11/b.txt"));

//2.一边读一边写
int b; //记录每次读取的一个字节
while((b=bis.read())!=-1){
    bos.write(b);
}

//3.关闭流
bis.close();
bos.close();

一次复制多个字节【重点】

//1.创建缓冲输入、输出流对象
BufferedInputStream bis =
    new BufferedInputStream(new FileInputStream("day11/a.txt"));

BufferedOutputStream bos =
    new BufferedOutputStream(new FileOutputStream("day11/b.txt"));

//2.一边读一边写
byte[] bs = new byte[1024];
int count; //记录每次读取的字节有效个数
while((count=bis.read(bs))!=-1){
    bos.write(bs,0,count);
}

//3.关闭流
bis.close();
bos.close();

字节缓冲流复制文件【重点】

BufferedInputStream和BufferedOutputStream用来对已有的InputStream和OutPutStream进行包装，从而提高读写效率。

//记录开始时间
long start = System.currentTimeMillis();

//读取a.exe文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\itheima\\a.exe"));

//写入b.exe文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\itheima\\c.exe"));

byte[] bs=new byte[1024];
int len; //读取的有效字节个数
while ((len=bis.read(bs))!=-1){
bos.write(bs,0,len);
}

//释放资源
bos.close();
bis.close();

//记录结束时间
long end = System.currentTimeMillis();
System.out.println(end-start);

day13_多线程

三种实现方式

常用方法

线程安全

死锁问题

多线程(基础)

生产者消费者案例

day01_

分支主题

快捷键

idea快捷键

ctrl+alt+t 选择用什么语句进行包裹