学习笔记——day14（String IO）

最新推荐文章于 2025-05-25 18:23:16 发布

陈肉肉

最新推荐文章于 2025-05-25 18:23:16 发布

阅读量252

点赞数

CC 4.0 BY-SA版权

分类专栏：学习笔记

本文链接：https://blog.youkuaiyun.com/Katherine_c/article/details/97285447

学习笔记专栏收录该内容

31 篇文章

订阅专栏

本文深入探讨了Java中的String类特性，包括intern()方法的使用、字符串拼接效率对比、StringBuilder与StringBuffer的区别，以及String类的不可变性。同时，文章还讲解了Calendar类的日期时间操作、File类的文件路径管理和常用方法，对比了mkdir与mkdirs创建目录的不同，并介绍了Java IO流的基本概念和使用，包括FileInputStream与FileOutputStream的读写操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

String 的面试题

intern（）用法

intern 获取到的是当前String对象的地址


public class Test01 {
    public static void main(String[] args) {
        String s1 = "Cat";
        String s2 = "Cat";
        String s3 = new String("Cat");
        
        System.out.println("s1 == s2 :"+(s1==s2));
        System.out.println("s1 == s3 :"+(s1==s3));
        
        String s4 = s1.intern();
        System.out.println("s1 == s4 :"+(s1==s4));
        System.out.println("s3 == s4 :"+(s4==s3));

    }
}
输出结果：
s1 == s2 :true
s1 == s3 :false
s1 == s4 :true
s3 == s4 :false

1: new 堆开空间
2： “zhangsan” 赋字面值常量池
3：+号拼接：
左右两边操作数如果是字面值则直接拼接之后再常量池开空间
如果左右两边操作数是变量则通过常量值重新分配空间存储变量地址

      public class Test02 {
        	public static void main(String[] args) {
        		String s1 = "Cat";
                String s2 = "Dog";
                final String s3 = s1+s2;// append 拼接的是新对象
                String s4 = "CatDog";
                String s5 = "Cat"+"Dog";//s5 = "CatDog"
                System.out.println(s3==s4);
                System.out.println(s4==s5);
                
                
        	}
        	
        	public static void test(Long in1){
        	    System.out.println(in1);
        	}
        	public static void test(long in1){
        	    System.out.println(in1);
        	}
        
        }
输出结果：
false
true

public class Test03 {
	public static void main(String[] args) {
		 test(10);
	     test(Integer.valueOf(10));

		
	}
	public static void test(Long in1){
	    System.out.println("1 "+in1);
	}
	
	public static void test(long in1){ 
		System.out.println("2 "+in1); 
		}
	 

}	
输出结果：
2 10
2 10
// 如果去掉了long in1 会报错

StringBuilder StringBuffer String的效率

	是否可变	效率	安全
String	不可变	+ 低	低
StringBuffer	可变	concat 中	中
StringBuild	可变	append 高	高

注意：如果“+”号左右两边是字面值，则效率最高

public class Test04 {
	public static void main(String[] args) {
		test01();
		test03();
		test02();
		String str = "ac";
	}
	
	public static void test01() {
		//计算test01这个程序运行的时间 end-start
		long start = System.currentTimeMillis();
		StringBuffer sb = new StringBuffer("a");
		for(int i = 0;i<100000;i++) {
			sb.append("c");
		}
		long end = System.currentTimeMillis();
		System.out.println("append运行的时间:"+(end-start));
	}
	
	public static void test02() {
		long start = System.currentTimeMillis();
		String sb = new String("a");
		for(int i = 0;i<100000;i++) {
			sb = sb+"c";
		}
		long end = System.currentTimeMillis();
		System.out.println("+号运行的时间:"+(end-start));
	}
	
	public static void test03() {
		long start = System.currentTimeMillis();
		String sb = new String("a");
		for(int i = 0;i<100000;i++) {
			 sb = sb.concat("c");
		}
		long end = System.currentTimeMillis();
		System.out.println("concat运行的时间:"+(end-start));
	}
	
}
输出结果：
append运行的时间:11
+号运行的时间:4765
concat运行的时间:2104

calendar的用法

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class Test01 {
	public static void main(String[] args) {
		// 创建对象
		Calendar c = Calendar.getInstance();
		
		
		System.out.println(c);
		
		Date d = new Date(1564019425340L);
		SimpleDateFormat sd = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
		String str = sd.format( d);
		System.out.println(str);
		
		System.out.println("获取当前日历中的天："+c.get(Calendar.DATE));
		System.out.println("获取当前日历中的天："+c.get(Calendar.DAY_OF_MONTH));
		System.out.println(c.get(Calendar.DAY_OF_WEEK));//星期从星期天开始 星期天是第一天
		System.out.println(c.get(Calendar.MONTH));
		
		
		
	}
}

import java.util.Calendar;
import java.util.GregorianCalendar;

/*
 *  c.setLenient(false);  设置是否开启格式检查  默认情况关闭
 * 
 */
public class Test02 {
	public static void main(String[] args) {
		
		
		//创建对象
		Calendar c = Calendar.getInstance();
		System.out.println(c);
		//add  累加会增位
		c.add(Calendar.DAY_OF_MONTH, 13);
		
		System.out.println(c.get(Calendar.DAY_OF_MONTH));
		System.out.println(c.get(Calendar.MONTH));
		
		c = Calendar.getInstance();
		//roll  不会增位
		c.roll(Calendar.DAY_OF_MONTH, 13);
		
		System.out.println(c.get(Calendar.DAY_OF_MONTH));
		System.out.println(c.get(Calendar.MONTH));
		 
		System.out.println("===");
		c = Calendar.getInstance();
		//传入参数如果是当前月份之内的天数 则设置为指定的日期 如果传入的是超过了字段值的数 则会增位
		c.setLenient(true);
		c.set(Calendar.DAY_OF_MONTH, 32);
		System.out.println(c.get(Calendar.DAY_OF_MONTH));
		System.out.println(c.get(Calendar.MONTH));
		
	}
}

file

file路径结束符和分割符

file:
抽象的路径以及文件
1：创建对象是无需注意当前路径或者是文件是否存在都会创建出来
2：和平台无关的路径分隔符
File.pathSeparator路径结束符 " ; "
File.separator路径分割符 " \ "

import java.io.File;

public class Test01 {
	public static void main(String[] args) {
		// 创建一个File对象
		File f = new File("C:\\Users\\wawjy\\Desktop");
		
		System.out.println(f);
		
		System.out.println(File.pathSeparator);
		System.out.println(File.pathSeparatorChar);
		System.out.println(File.separator);
		System.out.println(File.separatorChar);
		f = new File("C:"+File.separator+"Users"+File.separatorChar+"wawjy"+File.separatorChar+"Desktop");
		
	}
}
输出结果：
C:\Users\wawjy\Desktop
;
;
\
\

file的常见方法

查看是否可执行：canExecute();
查看是否可可写：canWrite();
查看是否可度：canRead()

比较的path： ff.compareTo(f) ff与f的路径相比较 equals();
获取路径： getPath()
创建文件一定要确保路径存在： createNewFile()
判断是否是绝对路径：isAbsolute()
获取绝对路径：getAbsolutePath()
获取文件名称：getName()
获取父级目录：getParent()
获取相对路径（项目根目录）：getPath()
获取磁盘剩余空间的大小：getFreeSpace()
获取磁盘总共大小：getTotalSpace()
获取磁盘可用大小：getUsableSpace()
下载临时文件并删除： temp.deleteOnExit()

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class Test02 {
	public static void main(String[] args) {
		
		// 创建对象
		File f = new File("C:\\Users\\wawjy\\Desktop\\cc.txt");
		
		System.out.println("查看是否可执行："+f.canExecute());
		System.out.println("查看是否可可写："+f.canWrite());
		System.out.println("查看是否可读："+f.canRead());
		
		File ff = new File("C:\\Users\\wawjy\\Desktop\\a.txt");
		//比较的path
		System.out.println(ff.compareTo(f));
		// 获取路径
		System.out.println(f.getPath());
		//比较路径
		System.out.println(ff.equals(f));
		
		try {
			//创建文件  确保路径存在
			System.out.println("创建文件是否成功："+f.createNewFile());
			
		}catch(IOException e) {
			e.printStackTrace();
		}
		
		
		f = new File("ccc.txt");
		try {
			f.createNewFile();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		System.out.println("是否是绝对路径："+f.isAbsolute());
		//获取绝对路径
		System.out.println("获取绝对路径："+f.getAbsolutePath());
		System.out.println("获取文件名称："+f.getName());// 获取文件名称
		System.out.println("获取父级目录："+f.getParent());
		System.out.println("获取相对路径(项目根目录)："+f.getPath());
		f = new File("c:\\");
		System.out.println("获取剩余大小："+f.getFreeSpace());
		System.out.println("获取总共大小："+f.getTotalSpace());
		System.out.println("获取可用大小："+f.getUsableSpace());
		System.out.println("是否是绝对路径："+f.isAbsolute());
		
		f = new File("C:\\Users\\wawjy\\Desktop\\cc.txt");
		
		long l = f.lastModified();
		Date d = new Date(l);
		SimpleDateFormat sd = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
		String str = sd.format(d);
		
		System.out.println(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date(l)));
		
		System.out.println(f.length());
		
		
		f = new File("c:\\");
		
		String[] strs = f.list();
		for(String st:strs) {
			System.out.println(st);
		}
		
		System.out.println("===================");
		File[] fs = f.listFiles();
		for(File file:fs) {
			System.out.println(file.getName()+"==="+file.length());
		}
		
		
	}
	//downLoad();
	public static void downLoad() {
		try {
			File d = new File("C:\\Users\\wawjy\\Desktop\\");
			File temp = File.createTempFile("hanhanzhenghan",".avi",d);
		
			TimeUnit.SECONDS.sleep(2);
			
			temp.deleteOnExit();
			
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

mkdir和mkdirs的区别

mkdir 只能创建一级目录
mkdirs 可以创建多级

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

public class Test03 {
	public static void main(String[] args) throws IOException {
		
		File file = new File("myfile\\aa\\aa.txt");
		
		//创建路径
		File filepath = new File("myfile\\aa");
		filepath.mkdirs();
		
		//创建文件
		file.createNewFile();
		
		file.setReadOnly();
		
		
	}
}

编写dir列出目录下的所有文件

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test04 {
	public static void main(String[] args) {
		//file对象
		File file = new File("c:\\");
		//获取当前file中的所有目录对象
		File[] fs = file.listFiles();
		//迭代所有file对象
		for(File f:fs) {
			String dateStr = new SimpleDateFormat("yyyy/MM/dd hh:mm").format(new Date(f.lastModified()));
			String isDirectory = f.isDirectory()?"<DIR>":"";
			String isFile = f.isFile()?String.valueOf(f.length()):"";
			String FileName = f.getName();
			System.out.println(dateStr+"\t"+isDirectory+"\t"+isFile+"\t"+FileName);
		}

IO

为什么需要IO

问题：
1： file类本身只能针对文件或者是目录的元数据(除了内容本身)进行操作不能对于文件中的内容做任何操作。
2：截止目前，我们存储数据的手段是很有限以及有问题的?
学习过的存储手段：
变量对象数组—> 存储都是在内存中的—>程序启动之后数据存在程序销毁之后数据丢失
但是在后期真个编码、项目的过程中：
我们对于数据一定要持久的存储起来方便后期使用以及更新
3: 无法将数据持久化存储起来。
解决办法：通过学习IO流的知识将数据写入到文件中去或者读取文件中的数据信息
文件时存储在磁盘上的，电脑关机之后，主要文件保存，那么开机之后数据还在。
IO:
IO: input output 输入输出
学习流的时候时候流是有方向的输入输出说的是针对谁的呢?

IO流的分类

IO流的分类：不是独立的分类而是相互
1：按照输出的数据类型不同：
字节流输出/输入时按照字节输出/输入
字符流输出/输入时按照字符输出/输入
2：按照流的方向
输入流
输出流
3：按照处理功能
节点流
处理流

InputStream

FileInputStream

读取单个字符

读取数据：

字节流：InputStream 是所有字节流的父类
输入：
子类：
FileInputStream: 文件字节输入流数据源在文件中读取按照字节读取流的方向是输入
每次读取数据时只能读一个字节，在通过read方法读取时如果
读取到了文件末尾，返回-1

public class Test02 {
	public static void main(String[] args) throws IOException {
		
		//创建对象
		File file = new File("C:\\Users\\wawjy\\Desktop\\cc.txt");
		InputStream is = new FileInputStream(file);
		
		//读取数据
		int bit = is.read();
		
		//输出数据
		System.out.println("读取到的数据是:"+(char)bit);
		
		//读取数据
		bit = is.read();
		
		//输出数据
		System.out.println("读取到的数据是:"+(char)bit);
		
		//读取数据
		bit = is.read();
		
		//输出数据
		System.out.println("读取到的数据是:"+(char)bit);
		
		//读取数据
		bit = is.read();
		
		//输出数据
		System.out.println("读取到的数据是:"+bit);
		
		//关闭资源
		is.close();
		
	}
}

循环读取

FileInputStream 创建要保证文件存在

public class Test03 {
	public static void main(String[] args) throws IOException {
		
		//1：创建对象
		InputStream is = new FileInputStream("C:\\Users\\wawjy\\Desktop\\cc.txt");
		
		int num = 0;
		//2:读取数据
		while((num=is.read())!=-1) {
			//3:分析数据
			System.out.println("读取数据："+num);
		}
		//4：关闭资源
		is.close();
		
		
		
	}
}

读取多个字节

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

/*
 * 
 *    一次性读取一个字节数组
 * 
 */
public class Test04 {
	public static void main(String[] args) throws IOException {
		//声明对象
		InputStream is = new FileInputStream("C:\\Users\\wawjy\\Desktop\\cc.txt");
		
		//读取数据
		//声明一个字节数组
		byte[] buf = new byte[1024];
		//读取一个字节数组长度的数据  返回读取到的字节数组的长度
		int len = is.read(buf);//会将数据读取到buf中
		
		//分析数据
		String msg = new String(buf,0,len);
		System.out.println(msg);
		
		//关闭资源
		is.close();
		
		
	}
}

处理异常

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class Test05 {
	public static void main(String[] args) {
		// 声明对象
		InputStream is = null;
		try {
			// 创建对象
			is = new FileInputStream("C:\\Users\\wawjy\\Desktop\\cc.txt");
			
			// 读取数据
			byte[] buf = new byte[1024];
			int len = is.read(buf);
			
			// 分析数据
			String msg = new String(buf,0,len);
			System.out.println(msg);
			
		}catch(FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(is!=null) {
					// 关闭资源
					is.close();
				}
			}catch(IOException e) {
				e.printStackTrace();
			}
			
		}
	
	}
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

// alt+shift+z  y
public class Test06 {
	public static void main(String[] args) throws Exception{
		
		//读取数据
		InputStream is = new FileInputStream("C:\\Users\\wawjy\\Desktop\\cc.txt");
		//声明一个字节数组
		byte[] buf = new byte[1024];
		//读取一个字节数组长度的数据  返回读取到的字节数组的长度
		int len = is.read(buf);//会将数据读取到buf中
		
		//分析数据
		String msg = new String(buf,0,len);
		System.out.println(msg);
		
		//关闭资源
		is.close();

		
		
	}
}

OutputStream

FileOutputStream

写出一个字符

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/*
 *  字节输出流：
 *  	所有字节输出流的父类都是OutputStrean
 * 		
 * 		子类：FileOutputStrean  输出的目的地是文件  输出流  输出的类型是字节
 *  
 *  输出时 如果文件不存在会创建该文件 但是不会创建目录
 * 
 */
public class Test07 {
	
	public static void main(String[] args) throws IOException {
		// 创建输出流对象
		OutputStream os = new FileOutputStream("abc.txt");
		
		//声明写出数据
		int num = 97;
		
		//写出数据
		os.write(num);
		
		
		//关闭
		os.close();
		
	}

}

写出多个字符

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 *  创建FileOutputStream对象时 第二个参数boolean值 说明是否在当前文件后追加内容
 *  默认情况是false 不追加 
 *  true是追加
 * 
 * @author wawjy
 *
 */
public class Test08 {
	public static void main(String[] args) throws IOException {
		
		//创建对象
		OutputStream os = new FileOutputStream("aaa.a",true);
		
		//声明写出的数据
		String msg = "laoxuezhideniyongyou";
		
		//写出数据
		os.write(msg.getBytes(),0,10);
		
		//关闭资源
		os.close();
		
		
		
	}
}

复制粘贴

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/*
 * 
 *   先打开后关
 * 
 */
public class Test09 {
	public static void main(String[] args) throws IOException {
		CtrlCV(null, null);
	}
	
	public static void CtrlCV(String srcFile,String destFile) throws IOException{
		/*
		 * //1:声明复制和粘贴的文件对象 String srcFile = "C:\\Users\\wawjy\\Desktop\\1.jpg"; String
		 * destFile = "123.jpg";
		 */
		
		//2:声明对象
		InputStream is = new FileInputStream(srcFile);
		OutputStream os = new FileOutputStream(destFile);
		
		//3：读取文件
		int len = 0;
		while((len=is.read())!=-1) {
			//写出
			os.write(len);
		}
		
		os.close();
		is.close();
		
	}
}