1、泛型
1.1 泛型概述
在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
大家观察下面代码：
public class GenericDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc");
coll.add("itcast");
coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
Iterator it = coll.iterator();
while(it.hasNext()){
//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
String str = (String) it.next();
System.out.println(str.length());
}
}
}
程序在运行时发生了问题java.lang.ClassCastException。为什么会发生类型转换异常呢？ 我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。
-
怎么来解决这个问题呢？
集合中可以存储各种对象，但实际上通常集合只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。
-
泛型：可以在类或方法中预支地使用未知的类型。
tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
1.2 使用泛型的好处
泛型带来了哪些好处呢？
-
将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
-
避免了类型强转的麻烦。
通过我们如下代码体验一下：
public class GenericDemo2 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>();
list.add("abc");
list.add("itcast");
// list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
tips:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。
1.3 泛型的定义与使用
我们在集合中会大量使用到泛型，这里来完整地学习泛型知识。
泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
2.3.1 定义和使用含有泛型的类
-
定义格式
修饰符 class 类名<代表泛型的变量> { }
-
举例
API中的ArrayList集合
class ArrayList<E>{ public boolean add(E e){ } public E get(int index){ } .... } -
自定义泛型类
public class MyGenericClass<MVP> { //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型 private MVP mvp; public void setMVP(MVP mvp) { this.mvp = mvp; } public MVP getMVP() { return mvp; } } -
如何使用泛型类
使用泛型： 即什么时候确定泛型。
在创建对象的时候确定泛型
-
举例
例如：
ArrayList<String> list = new ArrayList<String>();// 此时，变量E的值就是String类型 class ArrayList<String>{ public boolean add(String e){ } public String get(int index){ } ... }例如：
ArrayList<Integer> list = new ArrayList<Integer>();// 此时，变量E的值就是Integer类型 class ArrayList<Integer> { public boolean add(Integer e) { } public Integer get(int index) { } ... }
-
-
使用自定义泛型类
public class GenericClassDemo { public static void main(String[] args) { // 创建一个泛型为String的类 MyGenericClass<String> my = new MyGenericClass<String>(); // 调用setMVP my.setMVP("大胡子登登"); // 调用getMVP String mvp = my.getMVP(); System.out.println(mvp); //创建一个泛型为Integer的类 MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); my2.setMVP(123); Integer mvp2 = my2.getMVP(); } }
1.3.2 含有泛型的方法
-
定义格式
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
-
定义泛型方法
public class MyGenericMethod { public <MVP> void show(MVP mvp) { System.out.println(mvp.getClass()); } public <MVP> MVP show2(MVP mvp) { return mvp; } } -
泛型方法的使用
调用方法时，确定泛型的类型
public class GenericMethodDemo { public static void main(String[] args) { // 创建对象 MyGenericMethod mm = new MyGenericMethod(); // 演示看方法提示 mm.show("aaa"); mm.show(123); mm.show(12.45); } }
1.3.3 含有泛型的接口
-
定义格式
修饰符 interface接口名<代表泛型的变量> { }
-
定义泛型接口
public interface MyGenericInterface<E>{ public abstract void add(E e); public abstract E getE(); } -
泛型接口的使用
-
定义实现类时确定泛型的类型
public class MyImp1 implements MyGenericInterface<String> { @Override public void add(String e) { // 省略... } @Override public String getE() { return null; } }此时，泛型E的值就是String类型
-
始终不确定泛型的类型，直到创建对象时，确定泛型的类型
public class MyImp2<E> implements MyGenericInterface<E> { @Override public void add(E e) { // 省略... } @Override public E getE() { return null; } }确定泛型
/* * 使用 */ public class GenericInterface { public static void main(String[] args) { MyImp2<String> my = new MyImp2<String>(); my.add("aa"); } }
-
1.4 泛型通配符
1.4.1 什么是泛型通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
1.4.2 通配符基本使用
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。
举个例子大家理解使用即可：
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型
tips:泛型不存在继承关系 Collection<Object> list = new ArrayList<String>();这种是错误的。
1.4.3 通配符高级使用----受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限
-
泛型的上限
-
格式
类型名称 <? extends 类 > 对象名称 -
意义
只能接收该类型及该类型的子类
-
-
泛型的下限
-
格式
类型名称 <? super 类 > 对象名称 -
意义
只能接收该类型及该类型的父类型
-
比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<Integer>();
Collection<String> list2 = new ArrayList<String>();
Collection<Number> list3 = new ArrayList<Number>();
Collection<Object> list4 = new ArrayList<Object>();
getElement1(list1);
getElement1(list2);//报错
getElement1(list3);
getElement1(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
2、Collections
2.1 什么是Collections
Collections是针对集合操作的工具类
2.2 Collections常用的方法
| 方法名 | 说明 |
|---|---|
| public static void sort(List<T> list) | 将指定的列表按升序排序 |
| public static void reverse(List<?> list) | 反转指定列表中元素的顺序 |
| public static void shuffle(List<?> list) | 使用默认的随机源随机排列指定的列表 |
2.3 Collections代码演示
public class CollectionsDemo01 {
public static void main(String[] args) {
//创建集合对象
List<Integer> list = new ArrayList<Integer>();
//添加元素
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
// public static <T extends Comparable<? super T>> void sort(List<T> list)：将指定的列表按升序排序
// Collections.sort(list);
//public static void reverse(List<?> list)：反转指定列表中元素的顺序
// Collections.reverse(list);
//public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
Collections.shuffle(list);
System.out.println(list);
}
}
3、File类
3.1 什么是File类
java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
3.2 File类构造方法
| 方法名 | 说明 |
|---|---|
| public File(String pathname) | 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 |
| public File(String parent, String child) | 从父路径名字符串和子路径名字符串创建新的 File实例。 |
| public File(File parent, String child) | 从父抽象路径名和子路径名字符串创建新的 File实例。 |
代码演示
public class FileDemo{
public static void main(String[] args){
// 文件路径名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname);
// 文件路径名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2);
// 通过父路径和子路径字符串
String parent = "d:\\aaa";
String child = "bbb.txt";
File file3 = new File(parent, child);
// 通过父级File对象和子路径字符串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);
}
}
注意事项
-
一个File对象代表硬盘中实际存在的一个文件或者目录。
-
无论该路径下是否存在文件或者目录，都不影响File对象的创建。
3.3 获取功能方法
| 方法名 | 说明 |
|---|---|
| public String getAbsolutePath() | 返回此File的绝对路径名字符串。 |
| public String getPath() | 将此File转换为路径名字符串 |
| public String getName() | 返回由此File表示的文件或目录的名称。 |
| public long length() | 返回由此File表示的文件的长度。 |
代码演示
public class FileGet {
public static void main(String[] args) {
File f = new File("d:/aaa/bbb.java");
System.out.println("文件绝对路径:"+f.getAbsolutePath());
System.out.println("文件构造路径:"+f.getPath());
System.out.println("文件名称:"+f.getName());
System.out.println("文件长度:"+f.length()+"字节");
File f2 = new File("d:/aaa");
System.out.println("目录绝对路径:"+f2.getAbsolutePath());
System.out.println("目录构造路径:"+f2.getPath());
System.out.println("目录名称:"+f2.getName());
System.out.println("目录长度:"+f2.length());
}
}
3.4 绝对路径和相对路径
-
绝对路径：从盘符开始的路径，这是一个完整的路径。
-
相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。
public class FilePath {
public static void main(String[] args) {
// D盘下的bbb.java文件
File f = new File("D:\\bbb.java");
System.out.println(f.getAbsolutePath());
// 项目下的bbb.java文件
File f2 = new File("day10\\bbb.java");
System.out.println(f2.getAbsolutePath());
}
}
3.5 判断功能的方法
| 方法名 | 说明 |
|---|---|
| public boolean exists() | 此File表示的文件或目录是否实际存在。 |
| public boolean isDirectory() | 此File表示的是否为目录。 |
| public String getName() | 返回由此File表示的文件或目录的名称。 |
代码演示
public class FileIs {
public static void main(String[] args) {
File f = new File("d:\\aaa\\bbb.java");
File f2 = new File("d:\\aaa");
// 判断是否存在
System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
System.out.println("d:\\aaa 是否存在:"+f2.exists());
// 判断是文件还是目录
System.out.println("d:\\aaa 文件?:"+f2.isFile());
System.out.println("d:\\aaa 目录?:"+f2.isDirectory());
}
}
3.6 创建删除功能的方法
| 方法名 | 说明 |
|---|---|
| public boolean createNewFile() | 当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。 |
| public boolean delete() | 删除由此File表示的文件或目录。 |
| public boolean mkdir() | 创建由此File表示的目录。 |
| public boolean mkdirs() | 创建由此File表示的目录，包括任何必需但不存在的父目录。 |
代码演示
public class FileCreateDelete {
public static void main(String[] args) throws IOException {
// 文件的创建
File f = new File("aaa.txt");
System.out.println("是否存在:"+f.exists()); // false
System.out.println("是否创建:"+f.createNewFile()); // true
System.out.println("是否存在:"+f.exists()); // true
// 目录的创建
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
// 创建多级目录
File f3= new File("newDira\\newDirb");
System.out.println(f3.mkdir());// false
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());// true
// 文件的删除
System.out.println(f.delete());// true
// 目录的删除
System.out.println(f2.delete());// true
System.out.println(f4.delete());// false
}
}
注意事项
delete方法，如果此File表示目录，则目录必须为空才能删除。
3.7 目录的遍历
| 方法名 | 说明 |
|---|---|
| public String[] list() | 返回一个String数组，表示该File目录中的所有子文件或目录。 |
| public File[] listFiles() | 返回一个File数组，表示该File目录中的所有的子文件或目录。 |
public class FileFor {
public static void main(String[] args) {
File dir = new File("d:\\java_code");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
注意事项
调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。
4、 递归
4.1 什么是递归
指在当前方法内调用自己的这种现象。
4.2 递归的分类
递归分为两种，直接递归和间接递归。
-
直接递归称为方法自身调用自己。
-
间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
4.3 递归的注意事项
-
递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
-
在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
-
构造方法,禁止递归
public class Demo01DiGui { public static void main(String[] args) { // a(); b(1); } /* * 3.构造方法,禁止递归 * 编译报错:构造方法是创建对象使用的,不能让对象一直创建下去 */ public Demo01DiGui() { //Demo01DiGui(); } /* * 2.在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。 * 4993 * Exception in thread "main" java.lang.StackOverflowError */ private static void b(int i) { System.out.println(i); //添加一个递归结束的条件,i==5000的时候结束 if(i==5000){ return;//结束方法 } b(++i); } /* * 1.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 Exception in thread "main" * java.lang.StackOverflowError */ private static void a() { System.out.println("a方法"); a(); } }
4.4 递归累加求和
-
需求
计算1 ~ n的和
-
分析
num的和 = num + (num-1)的累和，所以可以把累和的操作定义成一个方法，递归调用。
-
代码实现
public class DiGuiDemo { public static void main(String[] args) { //计算1~num的和，使用递归完成 int num = 5; // 调用求和的方法 int sum = getSum(num); // 输出结果 System.out.println(sum); } /* 通过递归算法实现. 参数列表:int 返回值类型: int */ public static int getSum(int num) { /* num为1时,方法返回1, 相当于是方法的出口,num总有是1的情况 */ if(num == 1){ return 1; } /* num不为1时,方法返回 num +(num-1)的累和 递归调用getSum方法 */ return num + getSum(num-1); } }
4.5 递归求阶乘
-
什么是阶乘
所有小于及等于该数的正整数的积。
-
求N阶乘公式
n! = n * (n-1) ... 3 * 2 * 1
-
分析
这与累和类似,只不过换成了乘法运算，学员可以自己练习，需要注意阶乘值符合int类型的范围。
推理得出：n! = n * (n-1)!
-
代码实现
public class DiGuiDemo { //计算n的阶乘，使用递归完成 public static void main(String[] args) { int n = 3; // 调用求阶乘的方法 int value = getValue(n); // 输出结果 System.out.println("阶乘为:"+ value); } /* 通过递归算法实现. 参数列表:int 返回值类型: int */ public static int getValue(int n) { // 1的阶乘为1 if (n == 1) { return 1; } /* n不为1时,方法返回 n! = n*(n-1)! 递归调用getValue方法 */ return n * getValue(n - 1); } }
5、综合案例
5.1 打印多级目录
-
分析
多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。
-
代码实现
public class DiGuiDemo2 { public static void main(String[] args) { // 创建File对象 File dir = new File("D:\\aaa"); // 调用打印目录方法 printDir(dir); } public static void printDir(File dir) { // 获取子文件和目录 File[] files = dir.listFiles(); // 循环打印 /* 判断: 当是文件时,打印绝对路径. 当是目录时,继续调用打印目录的方法,形成递归调用. */ for (File file : files) { // 判断 if (file.isFile()) { // 是文件,输出文件绝对路径 System.out.println("文件名:"+ file.getAbsolutePath()); } else { // 是目录,输出目录绝对路径 System.out.println("目录:"+file.getAbsolutePath()); // 继续遍历,调用printDir,形成递归 printDir(file); } } } }
5.2 文件搜索
-
需求
搜索
D:\aaa目录中的.java文件。 -
需求分析
目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。
遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。
-
代码实现
public class DiGuiDemo3 { public static void main(String[] args) { // 创建File对象 File dir = new File("D:\\aaa"); // 调用打印目录方法 printDir(dir); } public static void printDir(File dir) { // 获取子文件和目录 File[] files = dir.listFiles(); // 循环打印 for (File file : files) { if (file.isFile()) { // 是文件，判断文件名并输出文件绝对路径 if (file.getName().endsWith(".java")) { System.out.println("文件名:" + file.getAbsolutePath()); } } else { // 是目录，继续遍历,形成递归 printDir(file); } } } }
66
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
