Java基础总结（刘意D20）
1:递归(理解)
(1)方法定义中调用方法本身的现象
举例：老和尚给小和尚讲故事，我们学编程
(2)递归的注意事项；
A:要有出口，否则就是死递归
B:次数不能过多，否则内存溢出
C:构造方法不能递归使用
(3)递归的案例：
A:递归求阶乘（两张图中说明了递归解决问题的思路及流程，程序在包2Demo中）
package cn.itcast_02;
/*
* 需求：请用代码实现求5的阶乘。
* 下面的知识要知道：
* 5! = 1*2*3*4*5
* 5! = 5*4!
*
* 有几种方案实现呢?
* A:循环实现
* B:递归实现
* a:做递归要写一个方法
* b:出口条件
* c:规律
*/
public class DiGuiDemo {
public static void main(String[] args) {
int jc = 1;
for (int x = 2; x <= 5; x++) {
jc *= x;
}
System.out.println("5的阶乘是：" + jc);
System.out.println("5的阶乘是："+jieCheng(5));
}
/*
* 做递归要写一个方法:
* 返回值类型：int
* 参数列表：int n
* 出口条件:
* if(n == 1) {return 1;}
* 规律:
* if(n != 1) {return n*方法名(n-1);}
*/
public static int jieCheng(int n){
if(n==1){
return 1;
}else {
return n*jieCheng(n-1);
}
}
}
**
B:兔子问题（程序在包2Demo2中）
package cn.itcast_02;
/*
* 有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？
* 分析：我们要想办法找规律
* 兔子对数
* 第一个月： 1
* 第二个月： 1
* 第三个月： 2
* 第四个月： 3
* 第五个月： 5
* 第六个月： 8
* ...
*
* 由此可见兔子对象的数据是：
* 1,1,2,3,5,8...
* 规则：
* A:从第三项开始，每一项是前两项之和
* B:而且说明前两项是已知的
*
* 如何实现这个程序呢?
* A:数组实现
* B:变量的变化实现
* C:递归实现
*
* 假如相邻的两个月的兔子对数是a,b
* 第一个相邻的数据：a=1,b=1
* 第二个相邻的数据：a=1,b=2
* 第三个相邻的数据：a=2,b=3
* 第四个相邻的数据：a=3,b=5
* 看到了：下一次的a是以前的b，下一次是以前的a+b
*/
public class DiGuiDemo2 {
public static void main(String[] args) {
// 定义一个数组
int[] arr = new int[20];
arr[0] = 1;
arr[1] = 1;
// arr[2] = arr[0] + arr[1];
// arr[3] = arr[1] + arr[2];
// ...
for (int x = 2; x < arr.length; x++) {
arr[x] = arr[x - 2] + arr[x - 1];
}
System.out.println(arr[19]);// 6765
System.out.println("----------------");
int a = 1;
int b = 1;
for (int x = 0; x < 18; x++) {
// 临时变量存储上一次的a
int temp = a;
a = b;
b = temp + b;
}
System.out.println(b);
System.out.println("----------------");
System.out.println(fib(20));
}
/*
* 方法： 返回值类型：int 参数列表：int n 出口条件： 第一个月是1，第二个月是1 规律： 从第三个月开始，每一个月是前两个月之和
*/
public static int fib(int n) {
if (n == 1 || n == 2) {
return 1;
} else {
return fib(n - 1) + fib(n - 2);
}
}
}
**
C:递归输出指定目录下所有指定后缀名的文件绝对路径（在包3FilePathDemo）
package cn.itcast_03;
import java.io.File;
/*
* 需求：请大家把E:\JavaSE目录下所有的java结尾的文件的绝对路径给输出在控制台。
*
* 分析：
* A:封装目录
* B:获取该目录下所有的文件或者文件夹的File数组
* C:遍历该File数组，得到每一个File对象
* D:判断该File对象是否是文件夹
* 是：回到B
* 否：继续判断是否以.java结尾
* 是：就输出该文件的绝对路径
* 否：不搭理它
*/
public class FilePathDemo {
public static void main(String[] args) {
// 封装目录
File srcFolder = new File("E:\\JavaSE");
// 递归功能实现
getAllJavaFilePaths(srcFolder);
}
private static void getAllJavaFilePaths(File srcFolder) {
// 获取该目录下所有的文件或者文件夹的File数组
File[] fileArray = srcFolder.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// 判断该File对象是否是文件夹
if (file.isDirectory()) {
getAllJavaFilePaths(file);
} else {
// 继续判断是否以.java结尾
if (file.getName().endsWith(".java")) {
// 就输出该文件的绝对路径
System.out.println(file.getAbsolutePath());
}
}
}
}
}
**
D:递归删除带内容的目录(小心使用)（在包3FileDeleteDemo）
package cn.itcast_03;
import java.io.File;
/*
* 需求：递归删除带内容的目录
*
* 目录我已经给定：demo
*
* 分析：
* A:封装目录
* B:获取该目录下的所有文件或者文件夹的File数组
* C:遍历该File数组，得到每一个File对象
* D:判断该File对象是否是文件夹
* 是：回到B
* 否：就删除
*/
public class FileDeleteDemo {
public static void main(String[] args) {
// 封装目录
File srcFolder = new File("demo");
// 递归实现
deleteFolder(srcFolder);
}
private static void deleteFolder(File srcFolder) {
// 获取该目录下的所有文件或者文件夹的File数组
File[] fileArray = srcFolder.listFiles();
if (fileArray != null) {
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// 判断该File对象是否是文件夹
if (file.isDirectory()) {
deleteFolder(file);
} else {
System.out.println(file.getName() + "---" + file.delete());
}
}
System.out
.println(srcFolder.getName() + "---" + srcFolder.delete());
}
}
}
2:IO流(掌握)
(1)IO用于在设备间进行数据传输的操作
(2)分类：（有图）
A:流向
输入流 读取数据
输出流 写出数据
B:数据类型
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流
注意：
a:如果我们没有明确说明按照什么分，默认按照数据类型分。
b:除非文件用windows自带的记事本打开我们能够读懂，才采用字符流，否则建议使用字节流。
(3)FileOutputStream写出数据（程序在包1FileOutputStreamDemo）
A:操作步骤
a:创建字节输出流对象
b:调用write()方法
c:释放资源
B:代码体现：
FileOutputStream fos = new FileOutputStream(“fos.txt”);
fos.write(“hello”.getBytes());
fos.close();
C:要注意的问题?
a:创建字节输出流对象做了几件事情?
1)创建字节输出流对象
2)写数据
3)释放资源
b:为什么要close()?
1)让流对象变成垃圾，这样就可以被垃圾回收器回收了
2)通知系统去释放跟该文件相关的资源
c:如何实现数据的换行?
为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
如何实现呢?写入换行符号即可呗。
刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
因为不同的系统针对不同的换行符号识别是不一样的?
windows:\r\n
linux:\n
Mac:\r
而一些常见的个高级记事本，是可以识别任意换行符号的。
d:如何实现数据的追加写入?
用构造方法带第二个参数是true的情况即可
package cn.itcast_01;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* IO流的分类：
* 流向：
* 输入流 读取数据
* 输出流 写出数据
* 数据类型：
* 字节流
* 字节输入流 读取数据 InputStream
* 字节输出流 写出数据 OutputStream
* 字符流
* 字符输入流 读取数据 Reader
* 字符输出流 写出数据 Writer
*
* 注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
*
* 需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
* A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
* B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
* 通过上面的分析后我们知道要使用：OutputStream
* 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
* 所以，我们要找一个具体的子类。
* 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
* 文件是哪个单词：File
* 然后用的是字节输出流，联起来就是：FileOutputStream
* 注意：每种基类的子类都是以父类名作为后缀名。
* XxxOutputStream
* XxxInputStream
* XxxReader
* XxxWriter
* 查看FileOutputStream的构造方法：
* FileOutputStream(File file)
* FileOutputStream(String name)
*
* 字节输出流操作步骤：
* A:创建字节输出流对象
* B:写数据
* C:释放资源
*/
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// FileOutputStream(File file)
// File file = new File("fos.txt");
// FileOutputStream fos = new FileOutputStream(file);
// FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
* 创建字节输出流对象了做了几件事情：
* A:调用系统功能去创建文件
* B:创建fos对象
* C:把fos对象指向这个文件
*/
//写数据
fos.write("hello,IO".getBytes());
fos.write("java".getBytes());
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close();
/*
* 为什么一定要close()呢?
* A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
* B:通知系统去释放跟该文件相关的资源
*/
//java.io.IOException: Stream Closed
//fos.write("java".getBytes());
}
}
**
(4)FileInputStream读取数据
A:操作步骤
a:创建字节输入流对象
b:调用read()方法
c:释放资源
B:代码体现：
FileInputStream fis = new FileInputStream("fos.txt");
//方式1
int by = 0;
while((by=fis.read())!=-1) {
System.out.print((char)by);
}
//方式2
byte[] bys = new byte[1024];
int len = 0;
while((len=fis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
fis.close();
**
(5)案例：2种实现
A:复制文本文件(在包3的CopyFileDemo中)
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 复制文本文件。
*
* 数据源：从哪里来
* a.txt -- 读取数据 -- FileInputStream
*
* 目的地：到哪里去
* b.txt -- 写数据 -- FileOutputStream
*
* java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
*
* 这一次复制中文没有出现任何问题，为什么呢?
* 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
* 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
* 它会自己做转换。
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("a.txt");
// 封装目的地
FileOutputStream fos = new FileOutputStream("b.txt");
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源(先关谁都行)
fos.close();
fis.close();
}
}
**
B:复制图片（在包3中的CopyImageDemo中）
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中
*
* 数据源：
* e:\\林青霞.jpg --读取数据--FileInputStream
* 目的地：
* mn.jpg--写出数据--FileOutputStream
*/
public class CopyImageDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
// 封装目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fos.close();
fis.close();
}
}
(6)字节缓冲区流（程序在包5中）
A:BufferedOutputStream
package cn.itcast_05;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
* 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
* 这种类被称为：缓冲区类(高效类)
* 写数据：BufferedOutputStream
* 读数据：BufferedInputStream
*
* 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
*
* 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
* 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
*/
public class BufferedOutputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
// 写数据
bos.write("hello".getBytes());
// 释放资源
bos.close();
}
}
**
B:BufferedInputStream
package cn.itcast_05;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/*
* 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
*/
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"bos.txt"));
// 读取数据
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
// 释放资源
bis.close();
}
}
3:IO流分类
(1)字节流：
A:InputStream
FileInputStream
BufferedInputStream
B:OutputStream
FileOutputStream
BufferedOutputStream
(2)字符流：
A:Reader
FileReader
BufferedReader
B:Writer
FileWriter
BufferedWriter
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
