package object;
public class Demo {
public static void main(String[] args) {
Point p = new Point(1,2);
System.out.println(p);
//其他类型在与字符串连接时，会调用其toString转换字符串后在进行连接
String line = "这个对象是：" + p;
System.out.println(line);
String str = p.toString();
System.out.println(str);
Point p2 = new Point(1,2);
System.out.println(p == p2);//对于引用类型而言，就是比较是否为"同一个对象"
System.out.println(p.equals(p2));//false
}
}
二、包装类
package object;
public class IntegerDemo02 {
public static void main(String[] args) {
//查看int最大值与最小值
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
System.out.println(max);//2147483647
System.out.println(min);//-2147483648
max = Byte.MAX_VALUE;
min = Byte.MIN_VALUE;
System.out.println(max);//127
System.out.println(min);//-128
max = Short.MAX_VALUE;
min = Short.MIN_VALUE;
System.out.println(max);//32767
System.out.println(min);//-32768
double max1 = Double.MAX_VALUE;
double min1 = Double.MIN_VALUE;
System.out.println(max1);
System.out.println(min1);
String line = "123";
int d = Integer.parseInt(line);
System.out.println(d);//123
line = "123.123";
double dou = Double.parseDouble(line);
System.out.println(line);//123.123
}
}
自动拆装箱
特性 JDK5之后推出了一个新的特性:自动拆装箱 该特性是编译器认可的.当编译器编译源代码时发现有基 本类型和引用类型相互赋值使用时会自动补充代码来完 成他们的转换工作,这个过程称为自动拆装箱.
package object;
public class IntegerDemo03 {
public static void main(String[] args) {
int a = 123;
Integer i = a;
// Integer i = (Integer) a；
a = i;
// a = i.intValue();编译器改好的样子
}
}
三、文件操作——File
1.1File类概述和构造方法
File:它是文件和目录路径名的抽象表示
文件和目录都是通过File封装成对象的对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。他可以是存在的，也可以是不存在的。将来要是通过具体的操作把这个路径的内容转换为具体存在的。
File类的每一个实例可以表示硬盘(文件系统)中的一个文件或目录(实际上表示的是一个抽象路径)
使用File可以做到:
1:访问其表示的文件或目录的属性信息,例如:名字,大小,修改时间等等2:创建和删除文件或目录3:访问一个目录中的子项
但是File不能访问文件数据.
File构造方法
| 方法名 | 说明 |
|---|---|
| File(String pathname) | 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例 |
| File(String parent, String child) | 从父路径名字符串和子路径字符串创建新的File实例 |
| File(File parent, String child) | 从父抽象路径名子路径字符串创建新的File实例 |
package file;
import java.io.File;
public class FileDemo {
public static void main(String[] args) {
//访问当前项目目录下的demo.txt文件
File file = new File("./demo.txt");
String name = file.getName();
System.out.println(name);//demo.tx
long length = file.length();
System.out.println("长度"+length+"字节");//长度10字节
boolean b = file.canRead();//可读
boolean b1 = file.canWrite();//可写
boolean b2 = file.isHidden();//是否隐藏
System.out.println("可读"+b);//true
System.out.println("可写"+b1);//true
System.out.println("隐藏"+b2);//没隐藏false,隐藏true
}
}
通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。
File f1 = new File("d:/LOL/java.txt");
System.out.println(f1);
从父路径名字符串和子路径字符串创建新的File实例。
File f2 = new File("d://LOL","java.txt");
System.out.println(f2);
从父抽象路径名子路径字符串创建新的File实例。
File f3 = new File("d://LOL");
File f4 = new File(f3,"java.txt");
1.2File类创建功能
| 方法名 | 说明 |
|---|---|
| public boolean createNewFile() | 当具有该名称的文件不存在是，创建一个由抽象路径名命名的新空文件。如果文件不存在就创建文件，并返回true；如果文件存在就不创建文件，并返回false。 |
| public boolean mkdir() | 创建由此抽象路径名命名的目录。如果目录不存在就创建目录，并返回true；如果目录存在就不创建目录，并返回false |
| public boolean mkdirs() | 创建由此抽象路径名命名的目录，包括任何必须但不存在的父目录。 |
//1.在d:/LOL目录下创建一个文件java.txt
File f1 = new File("d:/LOL/java.txt");
System.out.println(f1.createNewFile());
//2.在d:/LOL目录下创建一个目录javase
File f2 = new File("d:/LOL/javase");
System.out.println(f2.mkdir());
//3.在d:/LOL目录下创建一个多级目录javaweb/HTML
File f3 = new File("d:/LOL/javaweb/HTML");
//4.在d:/LOL目录下创建一个文件javase.txt
File f4 = new File("d:/LOL/javase.txt");
System.out.println(f4.createNewFile());
注意：文件和文件夹不能同名，mkdirs()可以创建多级目录。
package file;
import java.io.File;
public class MkdirDemo {
public static void main(String[] args) {
//在当前目录下创建一个目录：./demo
File file = new File("./demo");
if(file.exists()){//判断目录是否存在
System.out.println("目录已经存在");
}else{
// boolean mkdir = file.mkdir();
file.mkdir();//创建一个目录（文件夹）
System.out.println("目录已经成功创建了");
}
File file1 = new File("./a/b/c");
if(file1.exists()){
System.out.println("目录已经存在");
}else{
file1.mkdirs();//可以逐级创建目录
System.out.println("目录创建成功");
}
}
}
1.3File类判断和获取功能
| 方法名 | 说明 |
|---|---|
| public boolean isDirectory() | 测试此抽象路径名表示的File是否为日录 |
| public boolean isFile() | 测试此抽象路径名表示的File是否为文件 |
| public boolean exists() | 测试此抽象路径名表示的File是否为存在 |
| public String getAbsolutePath(） | 返回此抽象路径名的绝对路径名字符串 |
| public String getPath(） | 将此抽象路径名转换为路径名字符串 |
| public String getName(） | 返回此抽象路径名表示 的文件过目录的名称 |
| public String[] list() | 返回此抽象路径名表示的目录中的文件和目录的名称字符数组 |
| public File[] listFile() | 返回此抽象路径名表示的目录中的文件和目录的File对象数组 |
//FiLe类的判断和获职功能。
File f = new File("d:/LOL/java.txt");
//isDirectory():测试此抽象路经名表示的FiLe是否为目录
System.out.println(f.isDirectory());
//izFiLe( ):测试此拍象黯径名表示的Fz是否为文件
System.out.println(f.isFile());
//exists():测试此拍象路径名表示的FiLe是否存在
System.out.println(f.exists());
//getAbsolutePath():_返回此抽象路径名的绝对路径名字符串
System.out.println(f.getAbsoluteFile());
//geEPath():将此拍象路径名转预为路径名宁符串
System.out.println(f.getPath());
//getName():拉回由此抽象路径名表示的文件或自录的名称
System.out.println(f.getName());
// list()，返回此抽象路径名表示的日录中的文件和日录的名称字符串数组
System.out.println("-------------------------");
File f2 = new File("d:/LOL");
String[] strArray = f2.list();
for(String str : strArray){
System.out.println(str);
}
// ctrl +alt + v可以生成左边的内容
//listFiles()。返回此拍家路径名表示的目录中的文件和目录的FiLe对家数组
System.out.println("-------------------------");
File[] fileArray = f2.listFiles();
for(File file : fileArray){
System.out.println(file);
}//这种方法带路径，可以根据路径去调用方法
1.4 File类删除功能
| 方法名 | 说明 |
|---|---|
| delete() | 删除由此抽象路径名表示的文件或目录 |
绝对路径与相对路径的区别
绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：D:LOLjava.txt相对路径：必须使用取自其他路径名的信息进行解释。例如：LOLjava.txt
//1.3File类删除功能
//1.在当前模块目录下创建java.txt文件
File f1 = new File("java.txt");
System.out.println(f1.createNewFile());
//2.删除当前模块目录下创建java.txt文件
System.out.println(f1.delete());
//3.当前模块目录下创建LOL目录
File f2 = new File("LOL");
System.out.println(f2.mkdir());
//4.当前模块目录下删除LOL目录
System.out.println(f2.delete());
//5.当前模块目录下创建itcast目录，然后再次目录下创建一个文件java.txt
File f3 = new File("itcast");
System.out.println(f3.mkdir());
File f4 = new File("itcast/java.txt");
System.out.println(f4.createNewFile());
//6.删除当前模块目录下itcast目录(有内容不能直接删)
//System.out.println(f3.delete());
System.out.println(f4.delete());
System.out.println(f3.delete());
package file;
import java.io.File;
public class ListFilesDemo1 {
public static void main(String[] args) {
//获取当前目录中的所有子项
File dir = new File(".");
if(dir.isDirectory()){
File[] subs = dir.listFiles();
System.out.println("当前目录包含"+subs.length+"个子项");
for(int i=0;i
package file;
import java.io.File;
import java.io.FileFilter;
public class ListFilesDemo2 {
public static void main(String[] args) {
File dir = new File(".");
if(dir.isDirectory()){
// FileFilter filter = new FileFilter(){//匿名内部类创建过滤器
// public boolean accept(File file) {
// String name = file.getName();
// boolean starts = name.startsWith(".");//名字是否以"."开始
// System.out.println("过滤器过滤:"+name+",是否符合要求:"+starts);
// return starts;
// }
// };
// File[] subs = dir.listFiles(filter);//方法内部会调用accept方法
File[] subs = dir.listFiles(new FileFilter(){
public boolean accept(File file) {
return file.getName().startsWith(".");
}
});
System.out.println(subs.length);
}
}
}
1.5递归
概述：以递归的角度来看，递归指的是以方法定义中调用方法本身的现象。
public class DiGuiDemo {
public static void main(String[] args) {
int[] arr = new int[20];
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < arr.length; i++) {
arr[i] = arr[i-1] + arr[i-2];
}
System.out.println(arr[19]);
System.out.println(f(20));
}
public static int f(int n){
if (n==1 || n==2){
return 1;
}else{
return f(n-1)+f(n-2);
}
}
}
递归解决问题的思路：
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解；
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算。
1.6递归求阶乘#####
public class JieChengDemo {
public static void main(String[] args) {
//求5的阶乘
System.out.println("5的阶乘是"+f(5));
}
public static int f(int n){
if(n == 1){
return 1;
}else {
return n*f(n-1);
}
}
}
1.7遍历目录
package exercise.File;
import java.io.File;
public class DiGuiDemo2 {
public static void main(String[] args) {
File srcFile = new File("d:/LOL");
getAllFilePath(srcFile);
}
public static void getAllFilePath(File srcFile){
File[] fileArray = srcFile.listFiles();
if(fileArray != null){
for(File file : fileArray){
if(file.isDirectory()){
getAllFilePath(file);
}else {
System.out.println(file.getAbsoluteFile();
}
}
}
}
}
1.8递归删除目录
循环是重复执行某个步骤，而递归是重复整个过程
package file;
import java.io.File;
public class Test {
public static void main(String[] args) {
File dir = new File("./a");
delete(dir);
}
public static void delete(File file){
if(file.isDirectory()) {
//清空目录
File[] subs = file.listFiles();
for (int i = 0; i < subs.length; i++) {
File sub = subs[i];//从目录中获取一个子项
//将该子项删除
delete(sub);//递归调用
}
}
file.delete();
}
}
1.9Lambda表达式
JDK8之后，java支持了lambda表达式这个特性
lambda可以用更精简的代码创建匿名内部类，但是该匿名内部类实现的接口只能有一个抽象方法，否则无法使用。lambda表达式是编译器认可的，最终会将其改为内部类编译到class文件中
package lambda;
import java.io.File;
import java.io.FileFilter;
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类形式创建FileFilter
FileFilter filter = new FileFilter() {
public boolean accept(File file) {
return file.getName().startsWith(".");
}
};
FileFilter filter2 = (File file)->{
return file.getName().startsWith(".");
};
//lambda表达式中参数的类型可以忽略不写
FileFilter filter3 = (file)->{
return file.getName().startsWith(".");
};
FileFilter filter4 = (file)->file.getName().startsWith(".");
}
}
FileFilter filter = new FileFilter() {
public boolean accept(File file) {
return file.getName().startsWith(".");
}
};
FileFilter filter2 = (File file)->{
return file.getName().startsWith(".");
};
//lambda表达式中参数的类型可以忽略不写
FileFilter filter3 = (file)->{
return file.getName().startsWith(".");
};
FileFilter filter4 = (file)->file.getName().startsWith(".");
}
}
