在完成对C语言的学习后，我最近开始了对C++和Java的学习，目前跟着视频学习了一些语法，也跟着敲了一些代码，有了一定的掌握程度。现在将跟着视频做的笔记进行整理。本篇博客是整理Java知识点的第二十二篇博客。
本篇博客介绍了Java的Collections类和File类，以及递归。
本系列博客所有Java代码都使用IntelliJ IDEA编译运行，版本为2022.1。所用JDK版本为JDK11。
目录
Collections类
Collections类的概述和使用
Collections类是对集合操作的工具类。使用Collections类需要导包，import java.util.Collections
下面是Collections类的常用方法：
public static <T extends Comparable<? super T>> void sort(List<T> list)将指定的列表升序排序。
public static void reverse(List<?> list)反转指定列表中元素顺序。
public static void shuffle(List<?> list)使用默认的随机源随机排列指定列表。
import java.util.Collections;
import java.util.ArrayList;
public class collections {
public static void main(String[] args){
ArrayList<Integer> array = new ArrayList<Integer>();
array.add(19);
array.add(56);
array.add(48);
array.add(98);
array.add(15);
System.out.println(array);
Collections.reverse(array);
System.out.println(array);
Collections.sort(array);
System.out.println(array);
Collections.reverse(array);
System.out.println(array);
Collections.shuffle(array);
System.out.println(array);
Collections.shuffle(array);
System.out.println(array);
Collections.shuffle(array);
System.out.println(array);
}
}程序的输出是：
[19, 56, 48, 98, 15]
[15, 98, 48, 56, 19]
[15, 19, 48, 56, 98]
[98, 56, 48, 19, 15]
[48, 19, 15, 98, 56]
[15, 48, 56, 19, 98]
[19, 48, 56, 98, 15]
ArrayList存储学生对象并排序
public class studentsort {
private String name;
private int age;
public studentsort(){}
public studentsort(String name,int age){
this.name = name;
this.age = age;
}
public void setname(String name){
this.name = name;
}
public String getname(){
return name;
}
public void setage(int age){
this.age = age;
}
public int getage(){
return age;
}
}这是学生对象。
import java.util.Comparator;
import java.util.Collections;
import java.util.ArrayList;
public class studentsorttest {
public static void main(String[] args){
studentsort s1 = new studentsort("Isabel",19);
studentsort s2 = new studentsort("Ivan",18);
studentsort s3 = new studentsort("Linda",25);
studentsort s4 = new studentsort("Rita",17);
studentsort s5 = new studentsort("Emily",17);
studentsort s6 = new studentsort("Felix",15);
ArrayList<studentsort> listtest = new ArrayList<studentsort>();
listtest.add(s1);
listtest.add(s2);
listtest.add(s3);
listtest.add(s4);
listtest.add(s5);
listtest.add(s6);
Collections.sort(listtest, new Comparator<studentsort>(){
public int compare(studentsort s1,studentsort s2){
if(s1.getage() != s2.getage()){
return s1.getage() - s2.getage();
}else{
return s1.getname().compareTo(s2.getname());
}
}
});
for(studentsort s:listtest){
System.out.println("The name is " + s.getname() + " and the age is " + s.getage());
}
}
}这是测试代码，使用Collections类的sort方法时用参数指明了比较规则，升序排序，先比年龄再比姓名。程序的输出是：
The name is Felix and the age is 15
The name is Emily and the age is 17
The name is Rita and the age is 17
The name is Ivan and the age is 18
The name is Isabel and the age is 19
The name is Linda and the age is 25
模拟斗地主
import java.util.Collections;
import java.util.ArrayList;
public class pokertest1 {
public static void main(String[] args){
ArrayList<String> poker = new ArrayList<String>();
String[] flag={"♥","♣","♦","♠"};
String[] number = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for(String f:flag){
for(String n:number){
poker.add(f + n);
}
}
poker.add("Joker");
poker.add("joker");
Collections.shuffle(poker);
ArrayList<String> Alist = new ArrayList<String>();
ArrayList<String> Blist = new ArrayList<String>();
ArrayList<String> Clist = new ArrayList<String>();
int i;
for(i = 0; i < poker.size();i += 3){
Alist.add(poker.get(i));
Blist.add(poker.get(i + 1));
Clist.add(poker.get(i + 2));
}
System.out.print("A: ");
for(String s:Alist){
System.out.print(s + " ");
}
System.out.println();
System.out.print("B: ");
for(String s:Blist){
System.out.print(s + " ");
}
System.out.println();
System.out.print("C: ");
for(String s:Clist){
System.out.print(s + " ");
}
System.out.println();
}
}
程序实现了简单的发牌功能，给三个人发扑克牌。首先将表示54张牌的字符串加入ArrayList集合poker中。随后使用Collections的shuffle方法进行洗牌。然后创建了三个集合，表示三个用户，使用遍历的方法，每次向三个用户各自发一张牌。最后输出各自的牌。
下面是一次运行实例：
A: ♦J ♥4 ♣9 ♥10 ♣3 ♦7 ♣K ♥8 ♠4 ♣6 ♥6 ♠7 ♠5 ♣10 ♥7 ♥3 ♥2 ♠K
B: ♠10 ♥Q ♠6 ♣7 ♦3 ♦9 ♣Q ♦5 ♠Q ♠3 ♣4 ♦Q ♣J ♣2 ♦4 ♣A Joker ♦8
C: ♥K ♦10 ♦2 ♥5 ♥J ♣5 ♣8 ♦K ♦A ♥9 joker ♠A ♠J ♥A ♠8 ♦6 ♠2 ♠9
import java.util.HashMap;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.Collections;
public class pokertest2 {
public static void main(String[] args){
HashMap<Integer,String> poker = new HashMap<Integer,String>();
ArrayList<Integer> number = new ArrayList<Integer>();
for(int i = 1; i <= 54;i += 1){
number.add(i);
}
for(int i = 1; i <= 13;i += 1){
String temp;
if(i == 1){
temp = "A";
}else if(i == 11){
temp = "J";
}else if(i == 12){
temp = "Q";
}else if(i == 13){
temp = "K";
}else{
temp = "";
temp += i;
}
poker.put((i - 1) * 4 + 1,"♥" + temp);
poker.put((i - 1) * 4 + 2,"♦" + temp);
poker.put((i - 1) * 4 + 3,"♣" + temp);
poker.put((i - 1) * 4 + 4,"♠" + temp);
}
poker.put(53,"joker");
poker.put(54,"Joker");
Collections.shuffle(number);
TreeSet<Integer> Alist = new TreeSet<Integer>();
TreeSet<Integer> Blist = new TreeSet<Integer>();
TreeSet<Integer> Clist = new TreeSet<Integer>();
int i;
for(i = 0;i < 54;i += 3){
Alist.add(number.get(i));
Blist.add(number.get(i + 1));
Clist.add(number.get(i + 2));
}
System.out.println("A:");
for(int a:Alist){
System.out.print(poker.get(a) + " ");
}
System.out.println();
System.out.println("B:");
for(int b:Blist){
System.out.print(poker.get(b) + " ");
}
System.out.println();
System.out.println("C:");
for(int c:Clist){
System.out.print(poker.get(c) + " ");
}
System.out.println();
}
}
这段代码进行了略微的改进，使得结果能够按大小排序。
程序创建了一个ArrayList集合number，存储1至54。还有一个HashMap集合poker，键是编号，值是表示牌的字符串。顺序按号码从小到大表示，每四个编号代表一个号码的不同花色。53和54代表小王和大王。随后对number进行洗牌。然后创建三个TreeSet集合，表示用户。然后遍历number，每次向三个集合各加入一个数字。随后在输出时，根据对应number在poker中找到代表的扑克牌，输出表示扑克牌的字符串。
这是程序的一次运行结果：
A:
♦A ♥2 ♣3 ♦4 ♥5 ♦5 ♣5 ♥6 ♦6 ♥8 ♦9 ♠9 ♦10 ♥J ♣Q ♠Q ♥K ♠K
B:
♥A ♠A ♦3 ♥4 ♣6 ♦7 ♣7 ♠7 ♦8 ♣8 ♠8 ♥9 ♣10 ♦J ♣J ♥Q joker Joker
C:
♣A ♦2 ♣2 ♠2 ♥3 ♠3 ♣4 ♠4 ♠5 ♠6 ♥7 ♣9 ♥10 ♠10 ♠J ♦Q ♦K ♣K
File类
File类概述和构造方法
File类是文件和目录路径名的抽象表示。使用File类需要导包，import java.io.File
文件和目录可以通过File封装成对象。File封装的不是真正存在的文件，仅仅是路径名，可以不存在。会通过具体操作将路径的内容转换为具体存在。
File(String pathname)通过将给定的路径名字符串转换为抽象路径名在创建新的File实例。
File(String parent,String child)从父路径名字符串和子路径名字符串创建新的File实例。
File(File parent,String child)从父抽象路径名和子路径名字符串创建新的File实例。
所有有关File类的程序都是在本人电脑上运行，目录也是本人电脑的目录。结果仅与本人电脑一致，此处仅作实例，后面不再赘述。
另外注意，写目录时所有的\都要用\\表示。
import java.io.File;
public class filetest1 {
public static void main(String[] args){
File f1 = new File("D:\\Program Files");
System.out.println(f1);
File f2 = new File("D:\\Program Files","IDEA");
System.out.println(f2);
File f3 = new File(f1,"IDEA");
System.out.println(f3);
}
}程序的输出是：
D:\Program Files
D:\Program Files\IDEA
D:\Program Files\IDEA
File类创建功能
public boolean createNewFile()在具有该名称的文件不存在时，创建一个由该名称命名的新文件。
public boolean mkdir()创建此抽象路径名命名的目录。
public boolean mkdirs()创建此抽象路径名命名的目录，包括任何必需但不存在的目录。
这三个方法都是创建成功返回true，失败返回false。
import java.io.File;
import java.io.IOException;
public class filetest2 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:\\Program Files\\Java Project\\test.txt");
System.out.println(f1.createNewFile());
System.out.println(f1.createNewFile());
File f2 = new File("D:\\Program Files\\Java Project\\testtemp");
System.out.println(f2.mkdir());
File f3 = new File("D:\\Program Files\\Java Project\\testtmp\\tmptemp");
System.out.println(f3.mkdir());
System.out.println(f3.mkdirs());
}
}程序的输出是（事先没有创建这些内容）：
true
false
true
false
true
File类判断和获取功能
public boolean isDirectory()判断此抽象路径名表示的File是否为目录，是返回true，否则返回false。
public boolean isFile()判断此抽象路径名表示的File是否为文件，是返回true，否则返回false。
public boolean exists()判断此抽象名表示的File是否存在，存在返回true，否则返回false。
public String getAbsolutePath()返回此抽象路径名的绝对路径名字字符串。
public String getPath()将此抽象路径名转换为路径名字字符串。
public String getName()返回此抽象路径名表示的文件或目录的名称。
public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组。
public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组。
import java.io.File;
public class filetest3 {
public static void main(String[] args){
File f = new File("D:\\Program Files\\Java Project\\testtmp");
System.out.println(f.isDirectory());
System.out.println(f.isFile());
System.out.println(f.exists());
System.out.println(f.getAbsolutePath());
System.out.println(f.getPath());
System.out.println(f.getName());
String[] stringlist = f.list();
for(String s:stringlist){
System.out.println(s);
}
File[] filelist = f.listFiles();
for(File file:filelist){
System.out.println(file);
}
}
}本次运行接上一次的结果，程序的输出是：
true
false
true
D:\Program Files\Java Project\testtmp
D:\Program Files\Java Project\testtmp
testtmp
tmptemp
D:\Program Files\Java Project\testtmp\tmptemp
File类的删除功能
public boolean delete()删除此抽象路径名表示的文件或目录。删除成功返回true，否则返回false。
如果目录中有内容，则应先删除目录中的内容，然后再删除目录，删除后不进入回收站。实际可以直接删除里面有内容的目录，并且删除后会进入回收站。
import java.io.File;
public class filetest4 {
public static void main(String[] args){
File f1 = new File("D:\\Program Files\\Java Project\\test.txt");
System.out.println(f1.delete());
File f2 = new File("D:\\Program Files\\Java Project\\testtemp");
System.out.println(f2.delete());
File f3 = new File("D:\\Program Files\\Java Project\\testtmp");
System.out.println(f3.delete());
File f4 = new File("D:\\Program Files\\Java Project\\testtmp\\tmptemp");
System.out.println(f4.delete());
System.out.println(f3.delete());
}
}程序接上一步运行结果，程序的输出是：
true
true
false
true
true
递归
递归的概述
递归就是方法调用本身。递归将复杂问题层层转化为与原来问题相似的规模较小的问题。递归只需要少量程序就可以描述出解题过程。
递归要注意必须有递归出口，否则会报错。另外当递归执行太多层时会占用很大的空间，效率也会大大降低。
public class recursiontest1 {
public static void main(String[] args){
int result = rabbit(20);
System.out.println(result);
}
public static int rabbit(int n){
if(n == 1 || n == 2){
return 1;
}else{
return rabbit(n - 1) + rabbit(n - 2);
}
}
}rabbit方法参数是n，求斐波那契数列的第n位，并将结果返回。斐波那契数列前两位为1，其余每个都是前两个的和。因此可以设计递归，n大于等于3时，rabbit(n)等于rabbit(n - 1)和rabbit(n - 2)的和。n等于1或2就返回1。
程序的输出是：
6765
递归求阶乘
public class recursiontest2 {
public static void main(String[] args){
int result = fact(5);
System.out.println(result);
}
public static int fact(int n){
if(n == 1){
return 1;
}else{
return n * fact(n - 1);
}
}
}fact方法参数是n，返回n的阶乘。由阶乘的公式可知，n的阶乘等于n - 1的阶乘乘以n。可以据此设计递归。当n等于1时返回1。
程序的输出是：
120
遍历目录
import java.io.File;
public class lookcontent {
public static void main(String[] args){
File f1 = new File("D:\\Program Files\\C++ Project");
look(f1);
File f2 = new File("D:\\Program Files\\Java Project");
look(f2);
}
public static void look(File f){
File[] list = f.listFiles();
for(File file:list){
if(file.isDirectory() == true){
look(file);
}else{
System.out.println(f.getAbsolutePath());
}
}
System.out.println();
}
}look方法进行遍历，参数f是一个File类对象，无返回值。首先利用listFiles方法获取下一级File对象的数组。然后逐一遍历所得的File对象，如果对象绝对路径是目录，就进行递归遍历，将此对象作为参数，这样会递归到结果是目录为止。如果是文件，就输出路径。
由于输出很多（有1500行），因此不再展示。
3025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
