目录
1.什么是泛型
1. 泛型就是限制我们得数据类型。
2.为什么使用泛型?
我们原来在定义集合时，是如下得定义方式：
List list=new ArrayList();//该集合没有使用泛型
list.add("java01");
list.add("java02");
String str= (String) list.get(0);//获取元素 需要进行强制类型转换
System.out.println(str);
获取元素时，不方便对元素进行相应得其他操作。
1.1如何使用泛型
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("java01");
list.add("java02");
String s = list.get(0);
System.out.println(s);
HashMap<String, Integer> map = new HashMap<>();
map.put("name",1);
map.put("age",18);
Set<String> strings = map.keySet();
System.out.println(strings);
}
1.2自己定义泛型类
public class 类名<标识,标识....> {
标识 变量名;
public 标识 方法名(){
}
public void 方法名(标识 参数名){
}
定义坐标类：
package com.qy151.Dom1;
import java.awt.*;
public class Test3 {
public static void main(String[] args) {
//在创建泛型类对象时没有指定相应得泛型类型。则默认为Object类型
Point p1 = new Point();
p1.setX(15);
p1.setX("北纬50");
Point<Integer> p2 = new Point();
p2.setX(20);
p2.setY(30);
Integer x = p2.getX();
Integer y = p2.getY();
p2.show();
}
}
class Point<T> {
private T x;
private T y;
public Point() {
}
public Point(T x, T y) {
this.x = x;
this.y = y;
}
public void show() {
System.out.println("x坐标为:" + x + ";y坐标为:" + y);
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
2.FIle对象
2.1 File 的介绍
File 类 就是当前系统中 文件或者文件夹的抽象表示
通俗的讲 就是 使用File对象 来操作我们电脑系统中的文件或者文件
学习File类 其实就是学习 如果通过file对象 对系统中的文件/文件夹进行增删改查
2.2创建File对象
//第一种指定路径创建文件
File file = new File("F:\\AAA\\aaa.txt");
//第二种
File file1 = new File("F:/AAA/aaa.txt");
//第三种
File file2 = new File("F:"+File.separator+"AAA"+File.separator+"aaa.txt");
2.3增加操作
package com.qy151.Dom1;
import java.io.File;
import java.io.IOException;
public class Test05 {
public static void main(String[] args) throws IOException {
File fiel = new File("F:/AAA/aaa.txt");//创建file对象
fiel.createNewFile();//创建相应文件
File file01 = new File("F:/AAA/bbb");
file01.mkdir();//创建单层目录
File file02 = new File("F:/AAA/ccc/fff");
file02.mkdirs();//创建多层目录
File fiel03 = new File("F:/AAA/eee");//创建file对象
fiel.createNewFile();//创建相应文件
2.4删除
package com.qy151.Dom1;
import java.io.File;
public class Test06 {
public static void main(String[] args) {
File file = new File("F:/AAA/aaa.txt");
file.delete();//删除文件
File file1 = new File("F:/AAA/eee");
file1.deleteOnExit();//当程序退出后删除
}
}
2.5修改
package com.qy151.Dom1;
import java.io.File;
import java.io.IOException;
public class Test07 {
public static void main(String[] args) throws IOException{
File file = new File("F:/AAA/c.txt");
file.createNewFile();
//file.setReadable(false);//设置文件的权限为不能读
//file.setWritable(false);//设置文件不能写
//file.serReadOnly();//设置只读的权限
file.renameTo(new File("F:/AAA/d.txt"));//重命名
}
}
2.6查询
package com.qy151.Dom1;
import java.io.File;
import java.util.Arrays;
public class Test8 {
public static void main(String[] args) {
File file = new File("F:/AAA/ccc/fff/a.txt");
String name = file.getName();//得到文件名称
System.out.println("name======="+name);
String parent = file.getParent();//得到父级路径
System.out.println("parent======"+parent);
String path = file.getPath();//得到改文件的路径名
System.out.println("path======="+path);
boolean f1 = file.isFile();//判断该文件对象是否为文件类型
System.out.println("f1=========="+f1);
boolean f2 = file.isDirectory();//判断该文件对象是否为目录类型
System.out.println("f2=========="+f2);
File file1 = new File("F:/AAA");
String[] list = file1.list();//列出AAA目录下所有子文件对象名称
System.out.println(Arrays.toString(list));
File[] files = file1.listFiles();//列出AAA目录下所有文件对象
for(File f:files){
System.out.println(f.toString());
}
}
}
3.IO流
1.IO 表示有两个单词的缩写。
I: Input 输入 O: Output 输出
2. IO的作用：就是对文件中的内容进行操作。
输入: 读操作（读取文件的内容） 输出: 写操作(往文件中写内容)
3. IO流的分类
(1)根据流的方向:
---输入流: 程序可以从中读取数据的流。
---输出流: 程序能向其中写入数据的流。
(2)根据流的单位:
---字节流: 以字节为单位传输数据的流
---字符流: 以字符为单位传输数据的流
(3)根据功能
---节点流: 直接和文件进行交互
---处理流: 不是直接作用在文件上。
四个基本的流: 其他的流都是在这四个流的基础上进行扩展的
字节输入流
字节输出流
字符输入流
字符输出流
3.1Writer字符输出流
它是所有字符输出流的跟类。---FileWriter类
package com.qy151.Dom1;
import java.io.FileWriter;
import java.io.Writer;
public class TestWriter {
public static void main(String[] args) throws Exception{
//字符输出流 -- --指定对哪个文件 进行操作
//true：表示允许追加到内容到文件中
Writer w1 = new FileWriter("F:/AAA/d.txt",true);
String str = "hello 今天作业来了";
w1.write(str);
w1.flush();//刷新流
w1.close();//关闭资源流
}
}
3.2 Reader字符输入流
它是所有字符输入流的根类 它的实现类有很多，我们使用FileReader实现类
package com.qy151.Dom1;
import java.io.FileReader;
import java.io.Reader;
public class TestReader1 {
public static void main(String[] args) throws Exception{
Reader reader = new FileReader("F:/AAA/d.txt");
int count = 0;
char[] c =new char[15];
while((count=reader.read(c))!=-1){
String str = new String(c,0,count);
System.out.println(str);
}
// char[] c1 = new char[2];
// int i = reader.read(c1);
// System.out.println(i);
// System.out.println(c1);
// String s =new String(c1,0,i);
// System.out.println(s);
//
// i = reader.read(c1);
// System.out.println(i);
// System.out.println(c1);
// String s1 =new String(c1,0,i);
// System.out.println(s1);
//
// i = reader.read(c1);
// System.out.println(i);
// System.out.println(c1);
}
}
3.3字节输入和输出流
完成文件内容的复制
@Test
public void test02() throws Exception{
//1.创建一个字符输入流
FileReader fr=new FileReader("D:/AAA/d.txt");
//2.创建一个字符输出流
FileWriter fw=new FileWriter("C:/AAA/f.txt");
int c=0;//读取到字符的个数
char[] cs=new char[10];//每次读取的内容放入该数组中
while( (c=fr.read(cs)) !=-1 ){
fw.write(cs,0,c);
fw.flush(); //刷新
}
fw.close();
fr.close();
}
3.4字节流
3.4.1字节输出流--OutputStream
它可以对任意文件进行操作，对文件进行输出操作。以字节为单位。 它是所有字节输出流的父类，
//测试字节输出流
@Test
public void testOutStream() throws Exception{
OutputStream os = new FileOutputStream("F:/AAA/f.txt");
String str ="abcd";
//把字符串转为数组
byte[] bytes = str.getBytes();
os.write(bytes);
os.flush();
os.close();
}
3.4.2字节输入流--InputStream
它可以对任意文件进行读操作 ，以字节为单位，它是所有字节输入流的父类，子类有FileInputStream
@Test
public void testInputStream() throws Exception{
InputStream is = new FileInputStream("F:/AAA/f.txt");
byte[] bytes = new byte[3];
int c = is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数
System.out.println(bytes+"=================个数:"+c);
c = is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数
System.out.println(bytes+"=================个数:"+c);
c = is.read(bytes);//一次读取三个字节 并把读取的内容放入字节数组中 返回读取到字节的个数
System.out.println(bytes+"=================个数:"+c);
}
//如果文件中内容非常大 使用循环 来读取
@Test
public void testInputStream2() throws Exception{
InputStream is = new FileInputStream("F:/AAA/f.txt");
byte[] bytes = new byte[300];
int c = 0;
while ((c= is.read(bytes))!=-1){
//吧byte数组转为字符串
String str = new String(bytes,0,c);
System.out.println(str);
}
is.close();
}
使用字节输入和输出流完成文件的复制功能:
@Test
public void testCopy() throws Exception{
//1.创建字节输入流 图片
InputStream is=new FileInputStream("F:/AAA/1.jpg");
//2.字节输出流
OutputStream fos=new FileOutputStream("E:/AAA/2.jpg");
byte[] bytes=new byte[10];
int c=0;
while( (c=is.read(bytes)) !=-1 ){
fos.write(bytes,0,c);
fos.flush();
}
is.close();
fos.close();
}
3.5缓存流
缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能.
BufferInutStream BufferOutputStream BufferReader BufferWriter 提高IO的效率，降低IO的次数。
@Test
public void TestBuffer() throws Exception{
OutputStream out = new FileOutputStream("F:/AAA/g.txt");
BufferedOutputStream bos = new BufferedOutputStream(out);//缓存流要作用再基础流上
String str = "abcdefghijk";
byte[] bytes = str.getBytes();
bos.write(bytes); //因为你写的内容 暂时放入缓存池中 并没有直接放入文件中。 所以文件中没有你的内容。
//bos.flush();//刷新缓存池---把池子中的内容输入到文件上
bos.close();//关闭----先刷新缓冲池 再关闭流资源
}
3.6对象流--对java对象进行IO操作
我们现在操作IO流的时候 都是将字符串读写操作 可不可以将java对象在文件中进行读写呢？ 可以的 Student st=new Student();对象 将java对象进行读写操作 意义在于持久化信息 例如： 游戏存档。
// 因为运行的时候 所有的数据都是在运行内存中的 持久化 将运行内存的数据 保存到硬盘上 存档（写） 读档(读)
@Test
public void testObjectStream() throws Exception{
OutputStream out = new FileOutputStream("F:/AAA/a.txt");
//对象输出流
ObjectOutputStream oot = new ObjectOutputStream(out);
//使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口
Role r = new Role("张三","6级",007,"打李四");
oot.writeObject(r);
oot.close();
}
//测试 读档: ----反序列化:
@Test
public void testObjectStream2()throws Exception{
InputStream input=new FileInputStream("F:/AAA/a.txt");
ObjectInputStream ois = new ObjectInputStream(input);
Object o = ois.readObject();
System.out.println(o);
ois.close();
}
1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
---java对象所属的类必须实现序列化接口.implements Serializable
2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。
252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
