JAVA SE学习day_03:包装类、文件操作——file

最新推荐文章于 2024-07-20 23:55:03 发布

litter_m

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量194

点赞数

文章标签： java

本文链接：https://blog.csdn.net/litter_m/article/details/105834475

版权

一、包装类

包装类是为了解决基本类型不能直接参与面向对象开发的问题，实际就是将基本类型以“对象”的形式表示

Integer

1.1基本类型转换为对应的包装类（引用类型）

        int i=9;
		Integer i1 = new Integer(i);
		Integer i2 = new Integer(i);
		System.out.println(i1);//i
		System.out.println(i2);//i
		System.out.println(i1==i2);//false
		System.out.println(i1.equals(i2));//true

1.2 valueOf方法

所有的包装类类型都提供了静态方法valueOf，可以将对应的基本类型转换为包装类，并且这种方式也是Java的推荐方法；
注：限制同一对象重用不超过127次，超出则等同new的方式

        Integer i3 = Integer.valueOf(i);
		Integer i4 = Integer.valueOf(i);
		System.out.println(i3==i4);//t
		System.out.println(i3.equals(i4));//t
		
		Double d1 = Double.valueOf(123.456);
		Double d2 = Double.valueOf(123.456);
		//Double.valueof return new double not as Integer
		System.out.println(d1==d2);//f
		System.out.println(d1.equals(d2));//t

1.3 包装类转换为基本类型(XXX Value方法)

        int n = i1.intValue();
		System.out.println(n);
		
		double dou = d1.doubleValue();
		System.out.println(dou);

1.4 两个常量：MAX_VALUE和MIN_VALUE

包装类提供两个常量：MAX_VALUE和MIN_VALUE可以获取取值范围

//查看最大值和最小值
		int min = Integer.MIN_VALUE;
		int max = Integer.MAX_VALUE;
		
		long lmin = Long.MIN_VALUE;
		long lmax = Long.MAX_VALUE;
		
		double dmin = Double.MIN_VALUE;
		double dmax = Double.MAX_VALUE;
		
		System.out.println(max);
		System.out.println(min);
		System.out.println(lmax);
		System.out.println(lmin);
		System.out.println(dmin);
		System.out.println(dmax);

1.5 parseXXX(String str)方法△△△

重点知识点：
包装类提供了一个静态方法：parseXXX(String str)
可以将字符串解析为对应的基本类型数据，前提是该字符正确描述了基本类型可以保存的值；

        String str = "123";
		//String str = "123.123";
		int d = Integer.parseInt(str);
		System.out.println(d);//123    /!123,报错,未正确描述该基本类型
		
		double doub = Double.parseDouble(str);
		System.out.println(doub);//123.0   / 123.123

1.6 自动拆装箱特性

JDK1.5发布后，提供了一个新的特性：自动拆装箱

该特性是编译期认可的，作用是当编译期编译源代码时，发现有基本类型和引用类型相互赋值时会自动补充转换代码，这样以来我们在源代码中就可以在基本类型和对应的引用类型之间直接赋值了

        int d=90;
		/*
		 * 触发了编译期的自动装箱特性：基本类型-->包装类
		 * 编译器将代码改为：
		 * Integer i = Integer.valueOf(d)；
		 */
		Integer i = d;
		System.out.println(i);//90
		/*
		 * 触发了自动拆箱特性：包装类-->基本类型
		 * 编译器将代码改为：
		 * int n = i.integerValue(i)；
		 */
		int n = i;
		System.out.println(n);//90

二、file

java.io.File 其每一个实例用于表示一个文件或目录
File可以：

访问其表示的文件或目录的属性信息（名字、长度、读写权限等）
操作文件或目录
访问目录的子项
但不能访问文件的数据

       File file = new File("./demo.txt");
		String name = file.getName();
		System.out.println("文件名:"+name);
		long len = file.length();
		System.out.println("大小:"+len+"字节");

2.1 使用File创建一个文件

/*
		 * 当前目录下新建一个文件：text.txt
		 */
		File file = new File("./tese.txt");
		/*
		 * boolean exists()
		 * 该方法是用来判断当前File表示的路径对应的文件或目录是否
		 * 已经存在，存在则返回true
		 */
		if(file.exists()){
			System.out.println("文件已存在");
		}else {
			//在File表示的路径上将该文件真实创建出来
			file.createNewFile();
			System.out.println("文件已创建");
		}

2.2 创建一个目录

		/*
		 * 在当前目录下新建目录：demo
		 */
		File file = new File("./a/c/demo");
		if(file.exists()){
			System.out.println("目录已存在");
		}else{
			/*
			 * mkdir方法创建目录的前提是该目录所在的目录必须存在，否则无法创建
			 * mkdirs方法创建时会将所有不存在的父目录自动创建出来
			 */
			//file.mkdir();//创建该目录
			file.mkdirs();//无太多限制，如果没有路径则会自动创建路径
			System.out.println("目录已创建");
		}

2.3删除一个文件

/*
		 * 将当前项目下的test.txt文件删除
		 */
		File file = new File("./tese.txt");
		if(file.exists()){
			file.delete();
			System.out.println("文件已删除");
		}else{
			System.out.println("文件不存在");
		}

2.4删除一个目录

/*
		 * 删除当前目录下的demo目录
		 */
		File file = new File ("./a/c");
		if(file.exists()){
			/*
			 * delete方法再删除目录时有一个前提条件，就是该目录
			 * 必须是一个空目录，否则无法删除
			 */
			file.delete();
			System.out.println("目录已删除");
		}else{
			System.out.println("目录不存在");
		}

2.5 访问当前目录下的子项

访问当前目录下的所有子项：

/*
		 * 访问当前目录下的所有子项
		 */
		File file = new File("d:/");
		/*
		 * boolean isFile()
		 * 判断当前File表示的是否为一个文件
		 * 
		 * boolean isDirectiory（）
		 * 判断当前File表示的是否为一个目录
		 */
		if(file.isDirectory()){//首先判断是否为一个目录
			/*
			 * File[] listFiles()
			 * 获取所有子项，数组长度由目录中的子项决定，每个
			 * 元素是一个子项
			 */
			File[] subs = file.listFiles();
			System.out.println(subs.length);
			for(int i=0;i<subs.length;i++){
				File sub = subs[i];
				System.out.println(sub.getName());
			}
		}

获取当前目录下所有名字以"."开始的子项

/*
		 * 获取当前目录下所有名字以"."开始的子项
		 */
		File file = new File(".");//访问当前目录下的所有子项
		if(file.isDirectory()){
	//		MyFilter filter = new MyFilter();
			//匿名内部类写法
			FileFilter filter = new FileFilter(){
				public boolean accept(File file) {
					return file.getName().startsWith(".");
				}
			};
			/*
			 * 重载的listFiles方法在获取该目录所有子项目时，
			 * 会先将每一个子项（File对象）都调用一次给定的
			 * 过滤器的accept方法，并最终将返回为true的所有
			 * 子项返回
			 */
			File[ ]subs = file.listFiles(filter);
			System.out.println(subs.length);
			for(int i=0;i<subs.length;i++){
				File sub = subs[i];
				System.out.println("name:"+sub.getName());
			}
		}

2.6 lambda 更快的定义匿名内部类

lambda表达是JDK8后推出的一个新特性

lambda可以以更简洁的语法定义匿名内部类
不是所有使用匿名内部类的情况都可以用lambda代替，只有实现接口中
仅有一个抽象方法的时候才可以使用lambda
语法：
（参数列表）->{
```
   方法体代码
```
```
   }
```

//使用匿名内部类形式创建FileFilter
		FileFilter filter = new FileFilter(){
			public boolean accept(File pathname) {
				return pathname.getName().endsWith(".txt");
			}
			
		};
		/*
		 * lambda表达式是Java编译器认可的，最终会被编译器改为
		 * 内部类创建。并且编译器会结合程序上下文分析出实际上实例
		 * 化的是哪个类，以及重写的是哪个方法（因为接口要求只有
		 * 一个抽象方法，因此肯定是该方法）。并且方法的参数列表中
		 * 无需再定义参数的类型，只需要指定形参名即可
		 */
		FileFilter filter2 = (f)->{
			return f.getName().endsWith(".txt");
		};
		/*
		 * 当lambda中只有一句代码时，我们可以忽略“{}”，如果
		 * 这句代码含有return关键字，那么return关键字必须忽略
		 */
		FileFilter filter3 = (file)->file.getName().endsWith(".txt");
		
		File dir = new File(".");
		//File[]subs = dir.listFiles(filter3);
		File[]subs = dir.listFiles((f)->f.getName().endsWith(".txt"));
		System.out.println(subs.length);

2.7 递归方法

递归时整个流程重复执行
递归在开发中尽量避免，开销大，运行慢
使用递归注意事项：
1.方法内部调用当前方法称为递归
2.递归调用必须靠一个分支结构控制，不能必须执行，否则死循环
3.递归的层尽量少（内存开支大）

public static void main(String[] args) {
		File dir = new File("./a");
		delete(dir);
	}
	public static void delete(File file){
		/*
		 * 删除时首先判断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();
		
	}
}

练习

/*5 int ii=1;
		Integer ii1=Integer.valueOf(ii);
		int nn = ii1.intValue();
		String sre = "213";
		int num =Integer.parseInt(sre);
		double num1 = Double.parseDouble(sre);
		*/
		/*4 int ii = 1;
		Integer ii1 = Integer.valueOf(ii);
		int nn = ii1.intValue();
		String stra = "456";
		int num = Integer.parseInt(stra);
		double num1 = Double.parseDouble(stra);
		*/
		/*3 int ii = 1;
		Integer ii1 = Integer.valueOf(ii);
		int nn = ii1.intValue();
		String str = "123";
		int num = Integer.parseInt(str);
		doubele num1 = Double.parseDouble(str);
		*/
		/*2 int ii = 1;
		Integer ii1 = Integer.valueOf(ii);
		int nn = ii1.intValue();
		String zxc = "231";
		int num = Integer.parseInt(zxc);
		double num1 = Double.parseDouble(zxc);
		*/
		/*1int ii = 1;
		Integer ii1 = Integer.valueOf(ii);
		int nn = ii1.intValue();
		String as = "546";
		int num = Integer.parseInt(as);
		double num1 = Double.parseDouble(as);
		*/

/*5File file1  = new File(".");
		String name1 = file1.getName();
		long leng = file.length();
		System.out.println("文件名："+name+";大小："+leng+"字节");
		*/
		/*4File file1 = new File(".");
		String name1 = file1.getName();
		long leng = file.length();
		System.out.println("文件名："+name+";大小："+leng+"字节");
		*/
		/*3File file1 = new File(".");
		String name1 = file1.getName();
		long leng = file.length();
		System.out.println("文件名："+name+";大小："+leng+"字节");
		*/
		/*2 File file1 = new File(".");
		String name1 = file.getName();
		long leng = file.length();
		System.out.println("文件名："+name+";大小："+leng+"字节");
		*/
		/*1File file1 = new File(".");
		String name1 = file.getName();
		long leng = file.length();
		System.out.println("文件名："+name+";大小："+leng+"字节");
		*/

package file;

import java.io.File;
import java.io.IOException;

public class Exer {

	public static void main(String[] args) throws IOException {
		/*
		 * 生成一个项目a1下含有多级子目录和子项
		 * 定义并输出每个子项的名字
		 * 最后删除该项目
		 */
		File file = new File("./a1/c2/d3/demo");
		if(file.exists()){
			System.out.println("目录已存在");
		}else{
			file.mkdirs();
			System.out.println("目录已创建");
		}
		File text1 = new File("./a1/text1.txt");
		File text2 = new File("./a1/c2/text2.txt");
		File text3 = new File("./a1/c2/d3/text3.txt");
		File text4 = new File("./a1/c2/d3/demo/text4.txt");
		if(text1.exists()&&text2.exists()&&text3.exists()&&text4.exists()){
			System.out.println("文件已存在");
		}else{
			text1.createNewFile();
			text2.createNewFile();
			text3.createNewFile();
			text4.createNewFile();
			System.out.println("文件已创建");
		}
		File file1 = new File("./a1");
		show(file1);
		delete(file1);

	}
	public static void show (File f){
		if(f.isDirectory()){
			File[]subs = f.listFiles();
			for(int i=0;i<subs.length;i++){
				File sub = subs[i];
				show(sub);
			}
		} 
		System.out.println("name:"+f.getName());
		System.out.println("byte:"+f.length());
		System.out.println("read?:"+f.canRead());
		System.out.println("write?:"+f.canWrite());
		System.out.println("hidden?:"+f.isHidden());
	}
	public static void delete(File fi){
		if(fi.isDirectory()){
			File[]subs = fi.listFiles();
			for(int i=0;i<subs.length;i++){
				File sub = subs[i];
				delete(sub);
			}
		}
		fi.delete();
	}

}

package file;

import java.io.File;
import java.io.IOException;

import javax.xml.soap.Text;

public class Exer2 {

	public static void main(String[] args) throws IOException {
		/*5 File f =new File("./a1/c2/d3/demo");
		if(f.exists()){
			System.out.println("目录已存在");
		}else{
			f.mkdirs();
			System.out.println("目录已创建");
		}
		File text1 = new File("./a1/text1.txt");
		File text2 = new File("./a1/c2/text2.txt");
		File text3 = new File("./a1/c2/d3/text3.txt");
		File text4 = new File("./a1/c2/d3/demo/text4.txt");
		if(text1.exists()&&text2.exists()&&text3.exists()&&text4.exists()){
			System.out.println("文件已存在");
		}else{
			text1.createNewFile();
			text2.createNewFile();
			text3.createNewFile();
			text4.createNewFile();
			System.out.println("文件已创建");
		}
		File f1 = new File("./a1");
		show(f1);
		delete(f1);
		*/
		/*4 File f = new File("./a1/c2/d3/demo");
		if(f.exists()){
			System.out.println("目录已存在");
		}else{
			f.mkdirs();
			System.out.println("目录已创建");
		}
		File text1 = new File("./a1/text1.txt");
		File text2 = new File("./a1/c2/text2.txt");
		File text3 = new File("./a1/c2/d3/text3.txt");
		File text4 = new File("./a1/c2/d3/demo/text4.txt");
		if(text1.exists()&&text2.exists()&&text3.exists()&&text4.exists()){
			System.out.println("文件已存在");
		}else{
			text1.createNewFile();
			text2.createNewFile();
			text3.createNewFile();
			text4.createNewFile();
			System.out.println("文件已创建");
		}
		File ff = new File("./a1");
		show(ff);
		delete(ff);
		*/
		/*3File f = new File("./a1/c2/d3/demo");
		if(f.exists()){
			System.out.println("目录已存在");
		}else{
			System.out.println("目录已创建");
			f.mkdirs();
		}
		File text1 = new File("./a1/text1.txt");
		File text2 = new File("./a1/c2/text2.txt");
		File text3 = new File("./a1/c2/d3text3.txt");
		File text4 = new File("./a1/c2/d3/demo/text4.txt");
		if(text1.exists()&&text2.exists()&&text3.exists()&&text4.exists()){
			System.out.println("文件已存在");
		}else{
			text1.createNewFile();
			text2.createNewFile();
			text3.createNewFile();
			text4.createNewFile();
			System.out.println("文件已创建");
		}
		File ff = new File("./a1");
		show(ff);
		delete(ff);*/
		/*2
		File f =new File("./a1/c2/d3/demo");
		if(f.exists()){
			System.out.println("目录已存在");
		}else{
			f.mkdirs();
			System.out.println("目录已创建");
		}
		File text1 = new File("./a1/text1");
		File text2 = new File("./a1/c2/text2");
		File text3 = new File("./a1/c2/d3/text3");
		File text4 = new File("./a1/c2/d3/demo/text4");
		if(text1.exists()&&text2.exists()&&text3.exists()&&text4.exists()){
			System.out.println("文件已存在");
		}else{
			text1.createNewFile();
			text2.createNewFile();
			text3.createNewFile();
			text4.createNewFile();
			System.out.println("文件已创建");
		}
		File ff = new File("./a1");
		show(ff);
		delete(ff);*/
		/*1 File f =new File("./a1/c2/d3/demo");
		if(f.exists()){
			System.out.println("目录已存在");
		}else{
			f.mkdirs();
			System.out.println("目录已创建");
		}
		File text1 = new File("./a1/text1");
		File text2 = new File("./a1/c2/text2");
		File text3 = new File("./a1/c2/d3/text3");
		File text4 = new File("./a1/c2/d3/demo/text4");
		if(text1.exists()&&text2.exists()&&text3.exists()&&text4.exists()){
			System.out.println("文件已存在");
		}else{
			text1.createNewFile();
			text2.createNewFile();
			text3.createNewFile();
			text4.createNewFile();
			System.out.println("文件已创建");
		}
		File ff = new File("./a1");
		show(ff);
		delete(ff);*/
		
	}
	/*5 public static void show(File f){
		if(f.isDirectory()){
			File[]s =f.listFiles();
			for(int i=0;i<s.length;i++){
				File sa = s[i];
				show(sa);
			}
		}
		System.out.println("name:"+f.getName());
		System.out.println("byte:"+f.length());
		System.out.println("read?:"+f.canRead());
		System.out.println("write?:"+f.canWrite());
		System.out.println("hidden?:"+f.isHidden());
	}
    public static void delete(File f){
		if(f.isDirectory()){
			File[]as = f.listFiles();
			for(int i=0;i<as.length;i++){
				File ass = as[i];
				delete(ass);
			}
		}
		f.delete();
	}*/
	/*4
	public static void show(File f){
		if(f.isDirectory()){
			File[]as=f.listFiles();
			for(int i=0;i<f.length();i++){
				File aa = as[i];
				show(aa);
			}
		}
		System.out.println("name:"+f.getName());
		System.out.println("byte:"+f.length());
		System.out.println("read?:"+f.canRead());
		System.out.println("write?:"+f.canWrite());
		System.out.println("hidden?:"+f.isHidden());
	}
	public static void delete(File f){
		if(f.isDirectory()){
			File[]as = f.listFiles();
			for(int i=0;i<as.length;i++){
				File a1 = as[i];
				delete(a1);
			}
		}f.delete();
	}*/
	/*3
	public static void show(File f){
		if(f.isDirectory()){
			File[]as = f.listFiles();
			for(int i=0;i<f.length();i++){
				File e = as[i];
				show(e);
			}
		}
		System.out.println("name:"+f.getName());
		System.out.println("byte:"+f.length());
		System.out.println("read?:"+f.canRead());
		System.out.println("write?:"+f.canWrite());
		System.out.println("hidden?:"+f.isHidden());
	}
	public static void delete(File f){
		if(f.isDirectory()){
			File[]oo=f.listFiles();
			for(int i=0;i<oo.length;i++){
				File aa=oo[i];
				delete(aa);
			}
		}f.delete();
	}*/
	/*2 public static void show(File f){
		if(f.isDirectory()){
			File[]zz=f.listFiles();
			for(int i=0;i<zz.length;i++){
				File aa = zz[i];
				show(aa);
			}
		}
		System.out.println("name:"+f.getName());
		System.out.println("byte:"+f.length());
		System.out.println("read?:"+f.canRead());
		System.out.println("write?:"+f.canWrite());
		System.out.println("hidden?:"+f.isHidden());
	}
	public static void delete(File a){
		if(a.isDirectory()){
			File[]aa = a.listFiles();
			for(int i=0;i<aa.length;i++){
				File aaa=aa[i];
				delete(aaa);
			}
		}a.delete();
	}*/
	/*1public static void show (File f){
		if(f.isDirectory()){
			File[]subs = f.listFiles();
			for(int i=0;i<subs.length;i++){
				File sub = subs[i];
				show(sub);
			}
		} 
		System.out.println("name:"+f.getName());
		System.out.println("byte:"+f.length());
		System.out.println("read?:"+f.canRead());
		System.out.println("write?:"+f.canWrite());
		System.out.println("hidden?:"+f.isHidden());
	}
	public static void delete(File fi){
		if(fi.isDirectory()){
			File[]subs = fi.listFiles();
			for(int i=0;i<subs.length;i++){
				File sub = subs[i];
				delete(sub);
			}
		}
		fi.delete();
	}*/
	
	
}

litter_m

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JAVA SE学习day_03:包装类、文件操作——file

一、包装类包装类是为了解决基本类型不能直接参与面向对象开发的问题，实际就是将基本类型以“对象”的形式表示Integer1.1基本类型转换为对应的包装类（引用类型） int i=9; Integer i1 = new Integer(i); Integer i2 = new Integer(i); System.out.println(i1);//i Syste...
复制链接

扫一扫