1.泛型
1.1什么是泛型?
1.泛型就是限制我们的数据类型。
2.为什么使用泛型?
我们原来在定义集合时,是如下的定义方式:
List list = new ArrayList();//该集合没有使用泛型
list.add(“李白”);
list.add(“杜甫”);
String str = (String) list.get(0);//获取元素,需要进行强制类型转换
System.out.println(str);
获取元素时,不方便对元素进行相应的其他操作。
1.2如何使用泛型
List<类型>list=new ArrayList<类型>();只能在该集合中存储指定的类型。
/**
* @author:hzk
* @date 2022/4/19 20:47
*/
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();//这里就限制了集合中每个元素的类型。
list.add("李白");
list.add("杜甫");
list.add("赵云");//集合中只能添加String类型
String s = list.get(0);//在获取元素时,默认就是相应的数据类型,而无需再进行转换
System.out.println(s);
HashMap hashMap = new HashMap<>();
hashMap.put("收到",15);
}
}
1.3自定义泛型
public class 类名<标识,标识…>{
标识 变量名;
public 标识 方法名(){
}
public void 方法名(标识 参数名)
}
/**
* @author:hzk
* @date 2022/4/19 21:26
*/
public class Test3 {
public static void main(String[] args) {
//在创建泛型类对象时没有指定相应的泛型类型,默认为Object类型
Name N = new Name();
N.name=15;
N.sex=true;
//这里的泛型必须都是对象类型
Name<String> n = new Name<>();
n.setName("李白");
n.setSex("男");
n.show();
}
}
class Name<T>{
T name;
T sex;
public void show(){
System.out.println("姓名:"+name+"性别:"+sex);
}
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public T getSex() {
return sex;
}
public void setSex(T sex) {
this.sex = sex;
}
}
2.File对象
2.1file介绍
File类就是当前系统中文件或者文件夹的抽象表示,通俗的讲就是使用File对象来操作我们电脑系统中的文件或者文件夹。学习File类其实就是学习如何通过file对象对系统中的文件/文件夹进行增删改查。
2.2创建Fiel对象
1.磁盘准备一个目录A,以后对文件的操作都放在该目录下。
/**
* @author:hzk
* @date 2022/4/19 22:07
*/
public class Test4 {
public static void main(String[] args) {
File file = new File("D:\\A\\aaa.txt");
/*
\\目录层级,在window系统下层级分割符为\,但是在linux和mac系统上分割符为/.我们的java代码是一种
跨平台的语言,我们的开发在window,但是我们的项目部署在linux。为了使我们的代码能在任意系统下用,有两种方法
(1)因为window兼容/和\
*/
File file1 = new File("D:/A/a.txt");
//第二种 File.separator根据当前代码所在的系统自动获取相应的分割符
System.out.println(File.separator);// \是我们当前在window下
}
}
2.3增加操作
import java.io.File;
import java.io.IOException;
/**
* @author:hzk
* @date 2022/4/19 22:16
*/
public class Test5 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:/A/a.txt");//创建File对象
f1.createNewFile();//创建相应的文件
File f2 = new File("D:/A/b");
f2.mkdir();//创建目录
File f3 = new File("D:/A/C/c");
f3.mkdirs();//创建多级目录
}
}
2.4删除
File f4 = new File("D:/A/C/c");
f4.delete();
File f5 = new File("D:/A/C");
f5.deleteOnExit();//当程序退出后删除
Thread.sleep(5000);//休眠5秒
2.5修改
import java.io.File;
import java.io.IOException;
/**
* @author:hzk
* @date 2022/4/19 22:45
*/
public class Test6 {
public static void main(String[] args) throws IOException {
File f = new File("D:/A/a.txt");
f.createNewFile();
f.setWritable(false);//设置文件不能写
f.setReadOnly();//设置只读的权限
f.renameTo(new File("D:/A/b.txt"));//重命名
}
}
2.6查询
/**
* @author:hzk
* @date 2022/4/19 22:54
*/
public class Test7 {
public static void main(String[] args) {
File f = new File("D:/A/b.txt");
String name = f.getName();
System.out.println(name);//得到文件名
System.out.println(f.getParent());//得到父级目录
System.out.println(f.getPath());//得到文件路径名称
System.out.println(f.isFile());//判断文件对象是否为文件类型
System.out.println(f.isDirectory());//判断文件对象是否为目录类型
File f1 = new File("D:/A");
String[] list = f1.list();//列出A目录下所有子文件对象
System.out.println(Arrays.toString(list));
File[] files = f1.listFiles();//列出A目录下所有的文件对象
for (File n :files){
System.out.println(n.toString());
}
}
}
例题,递归调用
/**
* @author:hzk
* @date 2022/4/19 23:29
*/
public class Test82 {
public static void main(String[] args) {
showAll("D:/A");
}
public static void showAll(String path){
File file = new File(path);//设置输入路径
if(!file.isDirectory()||!file.exists()){//判断是个目录或者文件是否为空
return;
}
File[] files = file.listFiles();//列出目录下所有文件对象
for (File f:files){
if(f.isDirectory()){
System.out.println(f.getPath()+" Dir");
showAll(f.getPath());
}else {
System.out.println(f.getPath());
}
}
}
}
3.IO流
1.IO表示有两个单词的缩写
I:Input 输入 O:Output 输出
2.IO的作用:就是对文件中的内容进行操作
输入:读操作(读取文件的内容) 输出:写操作(往文件中写作内容)
3.IO流的分类:
(1)根据流的方向:
----输入流:程序可以从中读取数据的流
----输出流:程序能向其中写入数据的流
(2)根据流的单位
-----字节流:以字节为单位传输数据的流
-----字符流:以字符为单位传输数据的流
(3)根据功能
-----节点流:直接和文件进行交互
-----处理流:不是直接作用在文件上
四个基本的流:其他的流都是在这四个流的基础上进行扩展的
字节输入流
字节输出流
字符输入流
字符输出流
3.1Writer字符输出流
它是所有字符输出流的根类。—FileWriter类
/**
* @author:hzk
* @date 2022/4/20 10:18
*/
public class Test9 {
public static void main(String[] args) throws IOException {
//字符输出流 ---指定对哪个文件(路径)进行写作
Writer writer = new FileWriter("D:/A/c.txt");
Writer writer1 = new FileWriter("D:/B/c.txt",true);//追加内容
String str = "今天打王者荣耀";
writer1.write(str);
writer1.flush();//刷新流
writer1.close();//关闭流资源
}
}
3.2Reader字符输入流
它是所有字符输入流的根类,它的实现类有很多,我们使用FileReader实现类
/**
* @author:hzk
* @date 2022/4/20 10:35
*/
public class Test10 {
public static void main(String[] args) throws IOException {
//创建字符输入流对象,作用:读取c.txt里的内容
Reader reader = new FileReader("D:/A/c.txt");
int count = 0;//表示读取字符的个数
char[] cs = new char[2];//每次读取的元素存入该数组中
while ((count= reader.read(cs))!=-1){
String str = new String(cs,0,count);
System.out.println(str);
}
}
}
3.3完成文件内容的复制
/**
* @author:hzk
* @date 2022/4/21 10:34
*/
public class TestCopy {
public static void main(String[] args) throws IOException {
//创建字符输入流
FileReader f = new FileReader("D:/A/c.txt");
//创建字符输出流
FileWriter f1 = new FileWriter("C:/A/c.txt");
char[] cs = new char[2];//每次存入两个字符放入该数组中
int c= 0;//读取到字符的个数
while ((c=f.read(cs))!=-1){
f1.write(cs,0,c);
}
f.close();
f1.close();
}
}
4.字节流
4.1字节输出流–OutputStream
它可以对任意文件进行操作,对文件进行输出操作。以字节为单位。它是所有字节输出流的父类。FileOutputStream
/**
* @author:hzk
* @date 2022/4/21 10:45
*/
public class Test1 {
@Test
public void output()throws Exception{
OutputStream os = new FileOutputStream("D:/A/a.txt");
String s = "abc";
//将字符串转化为字节数组
byte[] bytes = s.getBytes();
os.write(bytes);
os.flush();
os.close();
}
}
4.2字节输入流—InputStream
它可以对任意文件进行读操作,以字节为单位,它是所有字节输入流的父类,子类有FileInputStream`
public void input()throws Exception{
InputStream is = new FileInputStream("D:/A/a.txt");
byte[] bytes = new byte[2];
int c= 0;
while ((c=is.read(bytes))!=0){
//将读取的byte数组转化为字符串
String s = new String(bytes,0,c);
System.out.println(s+" "+c);
}
is.close();
}
使用字节输入和输出流完成文件的复制功能:
public void copy()throws Exception{
//字节输入流
InputStream is = new FileInputStream("D:/A/a.txt");
//字节输出流
OutputStream os = new FileOutputStream("C:/A/c.txt");
byte[] bytes = new byte[2];
int c = 0;
while ((c=is.read(bytes))!=-1){
os.write(bytes,0,c);
}
is.close();
os.close();
}
5.缓存流
缓存流是在基础流[InputStream OutputStream Reader Writer]之上添加了一个缓存池功能。
BufferInputStream BufferOutputStream BufferReader Bufferwriter 提高IO的效率,降低IO的次数
@Test
public void Buffer()throws Exception{
OutputStream os = new FileOutputStream("D:/A/c.txt");
BufferedOutputStream bos = new BufferedOutputStream(os);//缓存流要作用在基础流上
String s = "dsds";
byte[] bytes = s.getBytes();
bos.write(bytes);//将内容暂时放入缓存池中,文件中没内容
bos.flush();//刷新缓存池---把池子中的内容输入到文件上
bos.close();//关闭----先刷新缓存池,在关闭流资源
}
6.对象流–对java对象进行IO操作
运行的时候,所有的数据都在运行内存中,持久化,将运行内存的数据保存到硬盘上。
/**
* @author:hzk
* @date 2022/4/21 9:51
*/
public class Player implements Serializable {
private String name;
private String level;
private String power;
public Player() {
}
public Player(String name, String level, String power) {
this.name = name;
this.level = level;
this.power = power;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public String getPower() {
return power;
}
public void setPower(String power) {
this.power = power;
}
@Override
public String toString() {
return "Player{" +
"name='" + name + '\'' +
", level='" + level + '\'' +
", power='" + power + '\'' +
'}';
}
}
@Test//存档 序列化
public void ObjectTest()throws Exception{
OutputStream os = new FileOutputStream("D:/A/a.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
Player p = new Player("马里奥","15级","全能属性");
oos.writeObject(p);
oos.close();
}
@Test//读档 反序列化
public void ObjectTest1()throws Exception{
InputStream is = new FileInputStream("D:/A/a.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Object o =ois.readObject();
System.out.println(o);
ois.close();
}
1序列化:把内存中的java对象存储到磁盘的过程。
java对象所属的类必须实现序列化接口:implement Serializable
2反序列化:把磁盘中的内容读取到java对象内存中的过程