1.JavaBean
javabean也可以称为实体类，其对象可以用于在程序中封装数据
2.==和equals
注意：在java中字符串的值是不可改变的，相同的字符串在内存中只会存一份
==比的是地址，而equals方法比的是值
equalsIgnoreCase忽略大小写进行比较
3.字符串常用方法
Java String类
创建字符串
创建一个String对象，并初始化一个值。
String类是不可改变的，一旦创建了一个String对象，它的值就不能改变了。
如果想对字符串做修改，需要使用StringBuffer&StringBuilder类。
//直接创建方式
String str1 = “abc”;
//提供一个 字符数组 参数来初始化字符串
char[] strarray = {‘a’,‘b’,‘c’};
String str2 = new String(strarray);
char为字符类型，String为字符串类型
String字符串是用" "来包含串的, char是用’ '来包含单字符的
String内部用来存储的结果是一个char字符数组
字符串长度获取
int length()方法：返回字符串对象包含的字符数。
int len = str.length();
连接字符串
String concat(String str)：连接两个字符串的方法
或者直接用‘+’操作符来连接
//String对象的连接
str1.concat(str2);
字符串查找
int indexOf(String s)：字符串s在指定字符串中首次出现的索引位置，如果没有检索到字符串s，该方法返回-1
int lastIndexOf(String s)：字符串s在指定字符串中最后一次出现的索引位置，如果没有检索到字符串s，该方法返回-1；如果s是空字符串，则返回的结果与length方法的返回结果相同，即返回整个字符串的长度。
int idx = str.indexOf(“a”);//字符a在str中首次出现的位置
int idx = str.lastIndexOf(“a”);
获取指定位置的字符串
char charAt(int index)方法：返回指定索引出的字符
String str = “abcde”;
char thischar = str.charAt(3);//索引为3的thischar是"d"
获取子字符串
String substring()方法：实现截取字符串，利用字符串的下标索引来截取(字符串的下标是从0开始的，在字符串中空格占用一个索引位置)
substring(int beginIndex)：截取从指定索引位置开始到字符串结尾的子串
substring(int beginIndex, int endIndex)：从beginIndex开始，到endIndex结束(不包括endIndex)
String str = “abcde”;
String substr1 = str.substring(2);//substr1为"cde"
String substr2 = str.substring(2,4);//substr2为"cd"
去除字符串首尾的空格()
String trim()方法
String str = " ab cde “;
String str1 = str.trim();//str1为"ab cde”
字符串替换
String replace(char oldChar, char newChar)：将指定的字符/字符串oldchar全部替换成新的字符/字符串newChar
String replaceAll(String regex, String replacement)：使用给定的参数 replacement替换字符串所有匹配给定的正则表达式的子字符串
String replaceFirst(String regex, String replacement)：使用给定replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
regex是正则表达式，替换成功返回替换的字符串，替换失败返回原字符串
String str = “abcde”;
String newstr = str.replace(“a”,“A”);//newstr为"Abcde"
判断字符串的开始与结尾
boolean startsWith()
boolean startsWith(String prefix)：判断此字符串是否以指定的后缀prefix开始
boolean startsWith(String prefix, int beginidx)：判断此字符串中从beginidx开始的子串是否以指定的后缀prefix开始
boolean endsWith(String suffix)：判断此字符串是否以指定的后缀suffix结束
String str = “abcde”;
boolean res = str.startsWith(“ab”);//res为true
boolean res = str.StartsWith(“bc”,1);//res为true
boolean res = str.endsWith(“de”);//res为true
判断字符串是否相等
boolean equals(Object anObject)：将此字符串与指定的对象比较，区分大小写
boolean equalsIgnoreCase(String anotherString)：将此 String 与另一个 String 比较，不考虑大小写
String str1 = “abcde”;
String str2 = str1;//字符串str1和str2都是一个字符串对象
String str3 = “ABCDE”;
boolean isEqualed = str1.equals(str2);//返回true
boolean isEqualed = str1.equals(str3);//返回false
boolean isEqualed = str1.equlasIgnoreCase(str3);//返回true
比较两个字符串
int compareTo(Object o)：把这个字符串和另一个对象比较。
int compareTo(String anotherString)：按字典顺序比较两个字符串。
比较对应字符的大小(ASCII码顺序)，如果参数字符串等于此字符串，则返回值 0；如果此字符串小于字符串参数，则返回一个小于 0 的值；如果此字符串大于字符串参数，则返回一个大于 0 的值。
String str1 = “abcde”;
String str2 = “abcde123”;
String str3 = str1;
int res = str1.compareTo(str2);//res = -3
int res = str1.compareTo(str3);//res = 0
int res = str2.compareTo(str1);//res = 3
把字符串转换为相应的数值
String转int型：
//第一种
int i = Integer.parseInt(String str)
//第二种
int i = Integer.valueOf(s).intValue();
String转long型：
long l = Long.parseLong(String str);
String转double型：
double d = Double.valueOf(String str).doubleValue();//doubleValue()不要也可
double d = Double.parseDouble(str);
int转string型：
//第一种
String s = String.valueOf(i)；
//第二种
String s = Integer.toString(i);
//第三种
String s = “” + i;
字符大小写转换
String toLowerCase()：将字符串中的所有字符从大写字母改写为小写字母
String toUpperCase()：将字符串中的所有字符从小写字母改写为大写字母
String str1 = “abcde”;
String str2 = str1.toUpperCase();//str2 = “ABCDE”;
String str3 = str2.toLowerCase();//str3 = “abcde”;
字符串分割
String[] split()：根据匹配给定的正则表达式来拆分字符串，将分割后的结果存入字符数组中。
String[] split(String regex)：regex为正则表达式分隔符, . 、 $、 | 和 * 等转义字符，必须得加 \；多个分隔符，可以用 | 作为连字符。
String[] split(String regex, int limit)：limit为分割份数
String str = “Hello World A.B.C”
String[] res = str.split(" “);//res = {“Hello”,“World”,“A.B.C”}
String[] res = str.split(” “,2);//res = {“Hello”,“World A.B.C”}
String[] res = str.split(”\.");//res = {“Hello World A”,“B”,“C”}
String str = “A=1 and B=2 or C=3”
String[] res = str.split(“and|or”);//res = {“A=1 “,” B=2 “,” C=3”}
字符数组与字符串的转换
public String(char[] value) ：通过char[]数组来创建字符串
char[] toCharArray()：将此字符串转换为一个新的字符数组。
String str = “abcde”;
char mychar[] = str.toCharArray();//char[0] = ‘a’; char[1] = ‘b’…
字符串与byte数组的转换
byte[] getBytes()
byte[] getBytes()：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes(String charsetName)：使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] Str2 = Str1.getBytes();
StringBuffer&StringBuilder类
与String类最大的不同在于这两个类可以对字符串进行修改。
StringBuilder相较StringBuffer来说速度较快，多数情况下使用StringBuilder，但是StringBuilder的方法不是线性安全的（不能同步访问），所以在应用程序要求线程安全的情况下，必须使用StringBuffer。
创建StringBuffer字符串
StringBuffer str = new StringBuffer(“”);
添加字符(最常用方法)
public StringBuffer append(String s)：将指定的字符串追加到字符序列中
str.append(“abc”);//此时str为“abc”
删除字符串中的指定字符
public delete(int start,int end)：移除此序列中的子字符串的内容
public deleteCharAt(int i)：删除指定位置的字符
str.delete(0,1);//此时str为“c”
str.deleteCharAt(str.length()-1);//删除最后一个字符
翻转字符串
public StringBuffer reverse()
str.reverse();
替换字符串中内容
replace(int start,int end,String str)：用String类型的字符串str替换此字符串的子字符串中的内容
String s = “1”;
str.replace(1,1,s);//此时str为"a1c"
插入字符
public insert(int offset, int i)：将int参数形式的字符串表示形式插入此序列中
str.insert(1,2);
字符串长度
int length()：返回长度（字符数）
void setLength(int new Length)：设置字符序列的长度
str.length();
str.setLength(4);
当前容量
int capacity()：获取当前容量
void ensureCapacity(int minimumCapacity)：确保容量小于指定的最小值
str.capacity();
将其转变为String
String toString()
str.toString();//将StringBuffer类型的序列转变为String类型的字符串
设置指定索引处的字符
void setCharAt(int index，char ch)：将给定索引处的字符设置为ch
4.static关键字
static是静态的意思，可以修饰成员变量和成员方法
static修饰成员变量表示该成员变量只在内存中存储一份，可以被共享访问和修改
static 修饰成员变量
public class User
{
public static String number=101;
}
//访问
User.number即可
static修饰成员方法
有static修饰的方法归属于类，建议用 类名.方法 来访问
static访问注意事项
静态方法只能访问静态的成员，不可以访问实例成员
实例方法可以访问静态的成员，也可访问实例成员
静态方法中不可以出现this关键字
代码块
代码块是类的五大成分之一(成员变量、构造器、方法、代码块、内部类)，定义在类中方法外
在java类下，使用{}括起来的代码被称为代码块
格式：static{}
特点：通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用
例如：斗地主初始化牌
单例模式
设计模式：开发中经常遇到一些问题，但其中肯定有一种解法是最优的，这个最优的解法被人总结来了，就是设计模式
设计模式有20多种，对应20多种软件开发中会遇到的问题
单例模式：保证系统中应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象
例如：任务管理器对象我们只需要一个就可以了，可以节省空间
单例实现方式：
饿汉单例设计模式：
即在类获取对象的时候，对象就已经提前为你创建好了
步骤：
1.定义一个类，把构造器私有
2.定义一个静态变量存储一个对象
调用结果：
懒汉单例模式
在真正需要改对象的时候，才去创建一个对象(延迟加载对象)
步骤：
1.定义一个类，把构造器私有
2.定义一个静态变量存储一个对象，并且将对象私有化private
3.提供一个返回单例对象的方法
调用：
继承
关键字extends 父类
构造器：子类构造器默认会访问父类无参数构造器再执行自己构造器
this，super关键字总结：
this代表本类对象的引用
super代表父类存储空间的标识
this的使用
访问成员变量：this.成员变量
访问成员方法：this.成员方法
super.成员变量 访问父类变量
super.成员方法 访问父类成员方法
this(...) 调用本类其他构造器
super(...) 访问父类构造器
注意：this(...),super(...)都只能放在构造器的第一行，所以二者不能同时存在一个构造器当中
包
同一个包下的类，互相可以直接访问
不同包下面的类，必须先导入包才可以继续访问
如果不同包下有相同类名，此时默认只能导入一个类的包，另一个类要使用全名访问即 :包名.类名
权限修饰符
是用来控制一个成员能够被访问的范围
可以修饰变量、方法、构造器、内部类。不同权限修饰符修饰的成员能够被访问的范围将受到限制
权限修饰符的分类和具体作用范围：
final关键字
final可以修饰类、方法、变量
修饰类：表明该类是最终类，不能被继承
修饰方法：表明该方法是最终方法、不能被重写
修饰变量：表示该变量是第一次赋值，不能再被赋值
常量
常量是使用了public static final 修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变
常量的作用好处：可以用于做系统的系统配置，方便程序的维护，同时也提高了可读性
常量名命规范：
英文单词全部大写
多个下划线连接起来
pulic static final String SCHOOL_HOME="传智教育";
枚举
枚举是java中的一种特殊类型(枚举类)
枚举的作用：是为了做信息的标识和信息的分类
注意：
枚举都是最终类，不可以被继承
枚举类都是继承了枚举类型：java.lang.enum
枚举类的构造器都是私有的，枚举类对外不能创造对象
枚举类的第一行默认都是罗列枚举对象(常量)的名称
枚举对象都是常量
抽象类
作用：通常用做模板
abstract修饰的类就是抽象类
abstract修饰的方法就是抽象方法
抽象类不能实例化
注意：一个类继承了抽象方法就必须重写抽象类的全部抽象方法，否则这个各类也必须定义为抽象类
abstract不能修饰代码块和构造器
接口
关键字：interface 实现： implements
实现接口的类称为实现类
一个类可以实现多个接口
接口的静态方法只能由本身的接口名来调用
1.接口不能实现其他接口，但是它可以继承多个接口
public interface StudentInterface extends PeopleInterface {
// 接口 StudentInterface 继承 PeopleInterface
int age = 25; // 常量age重写父接口中的age常量
void getInfo(); // 方法getInfo()重写父接口中的getInfo()方法
}
2.接口没有构造方法，不能被实例化。子接口可以对父接口的方法和常量进行重写。
3.接口中的都是全局常量和抽象方法，它会自动添加
public static final void 变脸名=value;
public abstract void 方法名(){}
日期和时间
1.Date类
getTime()获取毫秒值
setTime()方法：时间毫秒值恢复为日期对象
//1.创建一个Date类的对象
//表示当前时间
Date date=new Date();
System.out.println(date);
//获取当前时间的毫秒值
s=date.getTime();
//毫秒值恢复为日期对象
//方法1
Data date=new Date(s);
//方法2
date.setTime(s);
2.SimpleDateFormat类
将Date时间对象或时间毫秒值格式化为我们喜欢的时间形式
也可以吧字符串的时间形式解析为日期对象
构造器（输入喜欢的时间格式）
format(时间对象) 格式化时间
public static void main(String[] args) {
//格式化时间
Date date= new Date();
SimpleDateFormat slp=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String date_detail=slp.format(date);
System.out.println(date_detail);
}
运行结果：
parse(S) 解析时间，parse()方法返回一个Date类型的对象
//解析字符串时间成为日期对象
String str="2021年10月7日 10:32:32";
//把字符串时间解析为日期对象，形式必须要与被解析时间的形式完全一样，否则运行报错
SimpleDateFormat slp=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
try {
Date date = slp.parse(str);
System.out.println(date);
}
catch (Exception e)
{
System.out.println(e);
}
运行结果：
3.Calender类
//日期类Calender
//拿到系统此刻的日历对象
Calendar cal=Calendar.getInstance();
System.out.println(cal);
运行结果：
拿到当前系统日历之后，遍历数据
//日期类Calender
//拿到系统此刻的日历对象
Calendar cal=Calendar.getInstance();
System.out.println(cal);
//拿到日历后开始取数据
//取年
int year=cal.get(Calendar.YEAR);
//因为月数是从0开始的，所以要+1
int month=cal.get(Calendar.MONTH);
//取日
int day=cal.get(Calendar.DATE);
//取小时
int hour=cal.get(Calendar.HOUR);
//取分
int minute=cal.get(Calendar.MINUTE);
//取秒
int second=cal.get(Calendar.SECOND);
// 修改日历某个字段信息,这里将小时设置为12
// cal.set(Calendar.HOUR,12);
// System.out.println(cal);
//将当前月份加2
//cal.add(Calendar.MONTH,2);
Java中的装箱和拆箱
java 8中基本数据类型:
byte 8位
short 16位
int 32位
long 64位
boolean
float
double
char
注意：String是对象不是基本数据类型
Java为每种基本数据类型都提供了对应的包装器类型，让基本类型具备对象的特征,实现更多的功能.。
//自动装箱
Integer a1=10;
//自动拆箱
int a2=a1;
//valueof和parseInt/parseDouble方法将字符串数据转为整数和小数
int age=Integer.parseInt("16");
System.out.println(age);
Double score=Double.valueOf("16.3145");
System.out.println(score);
多态
不同的对象在执行同一个行为时会产生不同的行为特征
内部类
1.静态内部类
有static修饰，属于外部类本身
和普通类使用方式一样
注意：静态内部类可以访问外部类静态成员，不可以访问外部类实例成员
2.成员内部类
无static修饰，属于外部类的对象
可以访问外部类静态成员，也可以访问外部类实例成员
内部类实例化：
外部类名.内部类名 变量名=new 外部类构造器.new 内部类构造器;
3.局部内部类
局部内部类放在方法、代码块、构造器等执行体中
局部内部类的类文件名为：外部类$N内部类.class
4.匿名内部类（重点）
本质上是一个没有名字的局部内部类，定义在方法中，代码块中。
作用：
方便创建子类对象，最终目的为了简化代码编写
格式：
package com.itheima.classExercise;
public class Test {
public static void main(String[] args) {
//匿名内部类
//这里通过匿名内部类创建了一个Animals类的实现对象
//因为匿名内部类写出来就会产生一个匿名内部类对象
Animals animals=new Animals() {
@Override
public void run() {
System.out.println("老虎跑得快");
}
};
}
}
//class Tiger extends Animals
//{
// @Override
// public void run() {
// System.out.println("老虎会跑");
// }
//}
abstract class Animals
{
public abstract void run();
}
特点总结：
1.匿名内部类是一个没有名字的内部类
2.匿名内部类写出来就会产生一个匿名内部类的对象
3.匿名内部类的对象类型就是相当于当前new的那个类型的子类类型
常用API
Math数学类
Math.abs()取绝对值
Math.ceil()向上取整
Math.floor()向下取整
Math.round()四舍五入
Math.pow(2,3) 2的三次方
Math.random()取随机数
正则表达式
可以用一些规定的字符来制定规则，并且来校验数据格式的合法性
之前python学过
String类中
public boolean matches(String regex)
判断是否匹配正则表达式，匹配为true，否则为false
Arrays类
要求：学会Arrays类常用API方法
//1.toString(数组),返回数组内容
//定义数组
int []arr={1,2,3,4,5};
String str=Arrays.toString(arr);
System.out.println(str);
//2.排序
Arrays.sort(数组);
//3.二分查找
Arrays.binarySearch(数组名,要查找的数);
//前提为排好序的数组，否则出bug
//返回要查找的数的索引，如果没有，则返回负数
int []arr1={1,2,3,4,5};
System.out.println(Arrays.binarySearch(arr1,4));
集合
集合是java中存储对象数据的一种容器
集合中只能存储引用类型数据，如果存储基本数据类型可以选择用包装类
Collection集合特点：
List系列集合：添加元素有序、可重复、有索引
ArrayList、LinkedList
Set系列集合：元素无序、不重复、无索引
HashSet、LinkedHashSet
TreeSet：按照大小默认升序排列，不重复，无索引
集合支持泛型
集合的遍历
遍历就是一个一个的把容器中的元素访问一遍
迭代器java中的代表是iterator，迭代器是集合的专用遍历方式
代码部分：
//迭代器遍历
Collection <String> lists=new ArrayList<>();
lists.add("wangsan");
lists.add("xiaoming");
lists.add("miejue");
//迭代器
Iterator<String > iterator=lists.iterator();
while(iterator.hasNext()) {
String ele = iterator.next();
System.out.println(ele);
}
//foreach遍历
Collection <String> lists=new ArrayList<>();
lists.add("wangsan");
lists.add("xiaoming");
lists.add("miejue");
for(String ele:lists)
{
System.out.println(ele);
}
数据结构
栈：后进先出，先进后出
数据进入栈模型的过程为：压/进栈
队列：
先进先出，后进后出
数组：
查询较快，增删慢
链表：
链表中的元素是游离存储的，每个元素节点包含数据值和下一个元素的地址
查询速度慢，因为要从头查起
增删速度快，只需将下一节点的地址变为新加入节点的位置即可
List集合底层原理
ArrayList：
底层是基于数组实现的，根据索引定位元素块，增删需要做元素的位移操作
第一次创建集合并且添加第一个元素时候，会在底层创建一个默认长度为10的数组
LinkedList：
底层数据结构是双链表，查询慢，首尾操作的速度是极快的，
泛型
泛型是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并且进行检查
泛型格式：<数据类型>; 泛型只支持引用数据类型
集合的全部接口和实现类都支持泛型
代码:
ArrayList<Object> list=new ArrayList<>();
list.add(16);
list.add("zhangsan");
泛型类
定义类的同时定义了泛型的类就是泛型类
泛型类的格式
public class Student<T>{}
此处泛型变量T可以随便写为任意标识，常见的如E T K V等
作用： 编译阶段还可以指定数据类型，类似于集合的作用
演示： 模拟Arraylist定义一种类，关注泛型设计
泛型方法
格式：
public<T> void show(T t) {}
作用：方法中使用泛型接收一切实际类型的参数，使的方法更具有通用性
演示：
public static void main(String[] args) {
String []name={"12","23","34"};
Integer []age={14,15,16};
printArray(name);
printArray(age);
}
//定义泛型方法
public static <T> void printArray(T[] arr)
{
if (arr!=null)
{
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
}
else
{
System.out.println(" ");
}
}
泛型接口
public interface Data<E e>
{
void add(E e);
void delete(E e);
E queryId(int id);
}
作用：泛型接口可以让实现类选择当前功能需要操作的数据类型
泛型通配符
? 可以在使用泛型的时候代表一切类型
演示：
public class Collection_demo4 {
public static void main(String[] args) {
ArrayList<Dog> dog=new ArrayList<>();
ArrayList<cat> cat1=new ArrayList<>();
go(dog);
go(cat1);
}
public static void go(ArrayList<?> list)
{
}
}
class Dog
{
}
class cat
{
}
Set和Map集合
1.可变参数：
可变参数在形参中可以接收多个数据
格式：数据类型…参数名称
public void sum(int...a){}
//实现
sum();//无参
sum(10);
sum(10,20,30)
........
注意：一个形参列表中只能有一个可变参数，可变参数本质上是数组，且可变参数必须放在形参列表的最后
2.Collection工具类
//1.addAll()
List<String> names=new ArrayList<>();
//调用工具类addAll方法一键添加所有
Collection.addAll(names,"张三","李四","王二");
//2.打乱集合顺序
Collection.shuffle(names);
//3.排序
Collection.sort(names);//默认比较规则
//也可以自定义比较器
sort(Collection,compare)
3.Map
Map集合的特点都是由键决定的
Map集合键是无序的、不重复的、无索引的、值不做要求
Map中后面重复的键会覆盖前面重复的键
Map集合的键值都可以为null
HashMap：元素无序，不重复，无索引，值没有要求
LinkedHashMap：元素按照键是有序，不重复，无索引，值不做要求
Map遍历：
1.键找值
//拿到集合的全部键
Set<String> keys=maps.keySet();
//遍历每个键，然后取值
for(String key:Keys)
{
int value=maps.get(key);
System.out.print(key+"===>"+value);
}
2.键值对
先把Map集合转换为Set集合，Set集合中每个元素都是键值对实体类型
遍历Set集合，然后提取键和值
entrySet() 方法用于返回此映射中包含的映射关系的Set视图，Set 视图意思是 HashMap 中所有的键值对都被看作是一个 set 集合。
Map.entry<K,V>是一个抽象接口
Set<Map.Entry<String,Integer>> entries=maps.entrySet();
//开始遍历
for(Map.Entry<String,Integer> entry:entries)
{
String key=entry.getKey();
int value=entry.getValue();
System.out.println(key+"===>"+value);
}
3.迭代器
Iterator<Map.Entry<String,Integer>> entries=maps.entrySet().iterator();
while (entries.hasNext())
{
Map.Entry<String,Integer> entry=entries.next();
String key=entry.getKey();
Integer value=entry.getValue();
System.out.println(key+"==>"+value);
}
4.在 for 循环中使用 entries 实现 Map 的遍历（最常见和最常用的）
Map<String, String> map = new HashMap<String, String>();
map.put("Java入门教程", "http://c.biancheng.net/java/");
map.put("C语言入门教程", "http://c.biancheng.net/c/");
for (Map.Entry<String, String> entry : map.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
System.out.println(mapKey + "：" + mapValue);
Map的entrySet()方法返回一个实现Map.Entry接口的对象集合
日志技术
可以将系统执行的信息选择性的记录到指定的位置（控制台、文件中、数据库中）
可以随时以开关的形式控制是否记录日志，无需修改源代码
ASCII字符集
ASCII为美国信息交换标准代码，包括数字、英文、符号
ASCII使用1个字节存储一个字符，一个字节是8位，总共可以表示128个字符信息，对于英文、数字来说是够用的。
IO流
按方向分：
输入流
输出流
按流中的数据最小单位分：
字节流
字符流
流的四大类：
字节输入流：以字节的形式读入到内存中
InputStream is=new FileInputStream(File);
int read() :每次读取一个字节返回，无字节返回-1
int read(byte[] buffer)：每次读取一个字节数组
//一次读取全部字节
byte[] arr=new byte[(int) f.length()];
int read(arr)
字节输出流：以字节的形式写出到磁盘文件或网络
OutputStream FileoutputStream
void write()方法写数据到文件，以字节形式
write(byte[] arr)
write(byte[] arr,int pos,int len) 写出字节数组的一部分，以pos开始写len长度
字符输入流：以字符流的形式读入到内存
Reader FileReader
read()方法
read(char[] arr)
字符输出流：以字符流的形式写出到磁盘和网络介质
Writer FileWriter
write
资源释放
基本做法
try{}
catch{}
finally{}
//正常情况下，不管是否抛出或捕获异常 finally 块都会执行
序列化
1.缓冲流：缓冲流自带缓冲区，可以提高原始字节流、字符流读写数据的性能
字符流缓冲自带8K缓冲区
可以提高原始字符流读写数据的性能
字节缓冲输入流：BufferedInputStream
字节缓冲输出流: BufferedOutputStream
字符缓冲输入流：BufferedReader
字符缓冲输出流：BufferedWriter
2.转换流
编码：字符–>字节
解码：字节–>字符
1.字符输入转换流：InputStreamReader 可以把原始的字节流按照指定的编码换成字符输入流
public InputStreamReader(InputStream is)
public InputStreamReader(InputStream is,String charset)
作用：
可以解决字符流读取不同编码乱码的问题
2.字符输出转换流:OutputStreamReader 可以把原始的字节流按照指定的编码换成字符输出流
public OutputStreamReader(OutputStream is)
public OutputStreamReader(OutputStream is,String charset)
3.对象序列化
概念：以内存为基准，把内存中的对象存储到磁盘文件中去，方便下次使用。
使用到的流式对象字节输出流：ObjectOutputStream
public ObjectOutputStream(OutputStream out) throws IOException
//序列化方法
writeObject(对象)
1.创建学生类，包含get和set方法，有参和无参构造器，并且此类要实现序列化接口(Serializable接口)
2.实现代码
package com.itheima.app;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
//对象序列化
public class file_demo1 {
public static void main(String[] args) throws Exception {
//1.创建学生对象
Student student=new Student("陈磊","chenlei","123456",19);
//2.对象序列化
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("1.txt"));
//3.调用序列化方法
oos.writeObject(student);
//4.释放资源
oos.close();
}
}
4.对象反序列化
概念：以内存为基准，把存储到磁盘文件中去的对象数据恢复为内存中的对象，称为对象反序列化
使用到的流式对象字节输出流：ObjectInputStream
public ObjectInputStream(InputStream out) throws IOException
//反序列化方法
readObject() 把存储到磁盘文件中的数据恢复为内存中的对象
实现代码：
ObjectInputStream is=new ObjectInputStream(new FileInputStream("1.txt"));
//readObject()方法返回的对象默认为Object类型
Student stu=(Student) is.readObject();
System.out.println(stu);
注意：
//transient修饰的成员变量不参与序列化，即在反序列化的时候为null
private transient String name；
打印流
作用：打印流可以实现方便、高效的打印数据到文件中去
PrintStream,PrintWriter
ps.println(97);
ps.println("a");
......
输出语句重定向：
属于打印流的一种应用，可以把输出语句打印位置改到文件
PrintStream ps=new PrintStream("文件地址");
System.setOut(ps);
Properties
其实就是一个Map集合，但是一般不当集合使用，因为HashMap更好用
Properties核心作用：
properties代表的是一个属性文件，可以把自己对象中的键值对信息存入到一个属性文件中去
属性文件：后缀为.properties结尾的文件，里面内容都为key=value,后续做系统配置信息的
Properties properties=new Properties();
//put和setProperty都可以存数据(键值对)
properties.put("admin","123456");
properties.setProperty("zhangsan","123456");
//store()方法有两个参数，第一个是流，第二个是注释即对存入的数据解释说明
properties.store(new FileWriter("1.properties"),"this is users!!!");
//读取properties文件,加载属性文件中的键值对数据到properties中去
properties.load(new FileReader("1.properties"));
System.out.println(properties);
//根据key取value
String key1=properties.getProperty("admin");
String key2=properties.getProperty("zhangsan");
运行结果：
IO框架
commons-io
是Apache开源基金会组织提供的一组有关IO操作的类库，可以提高IO开发的效率
该工具包提供了许多有关IO操作的类，有两个主要的类FileUtils，IOUtils
使用步骤：
扫一扫
3318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
