软件设计之Java入门视频(19)
视频教程来自B站尚硅谷：
尚硅谷Java入门视频教程，宋红康java基础视频
相关文件资料（百度网盘）
提取密码：8op3
idea 下载可以关注 软件管家 公众号
学习内容：
该视频共分为1-717部分
本次内容涉及 570-599
在写代码时，总是需要来回切换界面来看代码要求，这里推荐Snipaste，可以把截图以窗口形式放在屏幕上
记录内容：
- 泛型
- File类
1、泛型
集合使用泛型
@Test
public void test2(){
ArrayList<Integer> list = new ArrayList<Integer>();//指明存放Integer类数据
//此处不能用基本数据类型<int>填写
list.add(78);
list.add(76);
list.add(80);
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
泛型类、泛型接口
public class Order <T>{
String orderName;
int orderId;
//类的内部结构可以使用类的泛型
T orderT;
public Order(String orderName, int orderId, T orderT) {
this.orderName = orderName;
this.orderId = orderId;
this.orderT = orderT;
}
public Order() {
}
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
}
使用泛型类造实例
@Test
public void test(){
//默认情况：不指明类的泛型 Order<Object> order = new Order<>();
Order<String> order = new Order<>("orderAA",1001,"1");
order.setOrderT("2");
System.out.println(order.getOrderT());
}
子类继承带泛型父类
情况1
public class SubOrder extends Order<Integer> {
public static void main(String[] args) {
//已经指明了泛型类型，实例化子类对象时不需再指明泛型
SubOrder subOrder = new SubOrder();
}
}
情况2
public class SubOrder<T> extends Order<T> {
public static void main(String[] args) {
//仍是泛型类
SubOrder<String> subOrder = new SubOrder<String>();
}
}
泛型方法
在方法中出现了泛型的结构，泛型参数与类的泛型参数没有关系
泛型方法可以声明为静态的，因为泛型参数是在调用方法时确定的，并非在实例化类的时候确定
//order类中定义
public <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for (E e : arr){
list.add(e);
}
return list;
}
//测试中调用
@Test
public void test(){
//默认情况：不指明类的泛型 Order<Object> order = new Order<>();
Order<String> order = new Order<>("orderAA",1001,"1");
Integer[] arr = new Integer[]{1,2,3};
//泛型方法在调用时，指定泛型参数的类型
List<Integer> list = order.copyFromArrayToList(arr);
System.out.println(list);
}
泛型在继承上的体现
虽然类A是类B的父类，但是
G<A>和G<B>二者不具备子父类关系，二者是并列关系。
类A是类B的父类，A<G>是B<G>的父类
@Test
public void test(){
AbstractList list1 = null;
List<String> list2 = null;
ArrayList<String> list3 = null;
list1 = list3;
list2 = list3;
}
通配符的使用
通配符
？
@Test
public void test(){
List<Object> list1 = null;
List<String> list2 = new ArrayList<>();
list2.add("1");
List<?> list = null;
list = list1;
list = list2;
//除了添加null以外，List<?>不能向其内部添加数据
list.add(null);
//获取(读取数据:允许读取数据，读取的数据类型为Object
Object o = list.get(0);
System.out.println(o);//1
}
有限制条件通配符
2、File类
File类常用方法
public boolean renameTo(File dest):
把文件重命名为指定的文件路径
file1.renameTo(file2) 意思就是把file1转移到file2所指定的目录下，并重命名。
File类对象的创建
@Test
public void test(){
//构造器1
//路径：day1(module)-->src-->File(软件包)-->FileTest
//对应绝对路径：E:\Java30days\Project\ untitled\day1\hello.txt (E:\Java30days\Project\ untitled部分忽略异同)
//注意：main方法中的相对路径对应的绝对路径是：E:\Java30days\Project\ untitled\ [相当于当前工程下]
File file1 = new File("hello.txt");//相当于当前module软件包下
File file2 = new File("E:\\Java30days\\Project\\untitled\\day1\\world.txt");
System.out.println(file1);//hello.txt
System.out.println(file2);//E:\Java30days\Project\ untitled\day1\world.txt
//构造器2
File file3 = new File("E:\\Java30days\\Project\\untitled","day1");
System.out.println(file3);// E:\Java30days\Project\ untitled\day1
//构造器3
File file4 = new File(file3,"hello.txt");
System.out.println(file4);//E:\Java30days\Project\ untitled\day1\hello.txt
}
流的分类
FileReader读取文件1
@Test
public void test() throws IOException {
//1.实例化File类的对象，指明要操作的文件
File file = new File("hello.txt");
//2.提供具体的流
FileReader fr = new FileReader(file);
//3.数据的读入
//read():返回读入的一个字符,如果达到文件末尾，返回-1
int data = fr.read();
while (data!= -1){
System.out.println((char)data);
data = fr.read();
}
//4.流的关闭操作
fr.close();
}
FileReader读取文件2(重载方法)
@Test
public void test() {
FileReader fr = null;
try {
//1.File类的实例化
File file = new File("hello.txt");
//2.FileReader流的实例化
fr = new FileReader(file);
//3.读入的操作
//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
char[] cbuffer = new char[5];
int len;
while ((len = fr.read(cbuffer)) != -1){
for (int i = 0; i < len; i++) {
System.out.print(cbuffer[i]);
}
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (fr != null){
//4.资源的关闭
try {
fr.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
FileWriter写入文件
1、输出操作，对应的File可以不存在的，并不会报异常
2、File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
3、File对应的硬盘中的文件如果存在：
①如果流使用的构造器是：FileWriter(file,false)/FileWriter(file):对原有文件的覆盖
②如果流使用的构造器是：FileWriter(file,false)/FileWriter(file):对原有文件的后续内容的添加
@Test
public void testFileWriter() throws IOException {
//1.提供File类的对象，指明写出到的文件
File file = new File("hello.txt");
//提供FileWriter的对象，用于数据的写出
FileWriter fw = new FileWriter(file);
//3.写出的操作
fw.write("I have a dream\n");
fw.write("you need to have a dream");
//4.流资源的关闭
fw.close();
}
FileInputStream &FileOutputStream
@Test
public void fileInputOutPutStream() throws IOException {
//1.提供File类的对象，指明写出到的文件
File srcFile = new File("Figure_1.png");
File destFile = new File("Figure_2.png");
//提供FileInput/OutputStream的对象，用于数据的写出
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//3.复制
byte[] buffer = new byte[5];
int len;//记录每次读取的字节的个数
while ((len = fis.read(buffer))!= -1){
fos.write(buffer,0,len);
}
//4.流资源的关闭
fis.close();
fos.close();
}
缓冲流
提供流的读取与写入的速度
原因:提供了一个缓存区
@Test
public void BufferedStreamTest() throws IOException {
//1.造文件
File srcFile = new File("Figure_1.png");
File destFile = new File("Figure_2.png");
//2.造流
//2.1造节点流
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//2.2造缓冲流
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//3.复制的细节：读取、写入
byte[] buffer = new byte[10];
int len ;
while ((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
}
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
bis.close();
bos.close();
//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，可以省略
// fis.close();
// fos.close();
}
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
