黑马程序员_JavaSE基础知识总结十六：流与文件

liulin90 liulin90 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 858平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄11年
关注
原创 最新推荐文章于 2026-02-27 12:05:35 发布 858 阅读 AI 写同款· GEO 优化 ›
AI权益加码！Claude Code、Cursor等20+工具免费用！ 购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！ 阅读详情

------android培训、java培训、期待与您交流！ ----------



一、什么是文件

文件，对我们并不陌生，文件是数据源(保存数据的地方)的一种，比如大家经常使用的word文档、txt文件、excel文件...都是文件。文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保存视频、声音...等。

 

文件流--基本概念

文件在程序中是以流的形式来操作的


流：数据在数据源(文件)和程序(内存)之间经历的路径

输入流：数据从数据源(文件)到程序(内存)的路径

输出流：数据从程序(内存)到数据源(文件)的路径

 

如何判断是输入流、输出流？

以内存为参照，如果数据流向内存流动，则是输入流；反之，则是输出流。

 

文件流--分类

java流分为两种流

1、字节流：可以用于读写二进制文件及任何类型文件byte

2、字符流：可以用于读写文本文件，不能操作二进制文件

字节流字符流

输入InputStreamReader

输出OutputStreamWriter

 

常用io流--文件对象

目的：文件数据源File类介绍(文件流对象中最为重要的File类，对File了解后对子类理解会更加容易。


 

Java流操作有关的类或接口

类

说明

File

文件类

RandomAccessFile

随机存取文件类

InputStream

字节输入流

OutputStream

字节输出流

Reader

字符输入流

Writer

字符输出流

 

 

流的概念和作用

流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流.

流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作.

 

IO流的分类

根据处理的数据类型的不同分为: 字节流和字符流.

根据数据流向不同分为: 输入流和输出流.

 

字节流和字符流

字符流的由来: 因为数据编码的不同,,而有了对字符进行高效操作的流对象,本质其实就是基于字节流读取时去查了指定的编码表.字节流和字符流的区别:

读写单位不同: 字节流以字节(8bit)为单位,字符流以字符为单位没根据编码表映射字符,一次可能读多个字节.

处理对象不同: 字节流处理所有类型的数据(如图片,AV等等),而字符流只能处理字符类型的数据.

 

结论: 只要处理纯文本数据,就优先考虑使用字符流,除此之外都使用字节流.

 

输入输出流

对输入流只能进行的操作,对传输流只能就行写操作,程序中需要根据待传输数据的不同特性而使用不同的流.

 

Java IO流对象

1,输入字节流InputStream()中输入字节流的继承图可见上图,可以看出:

1,InputStream是所有的输入字节流的父类,它是一个抽象类.

2,ByteArrayInputStream, StringBufferInputStream, FileInputStream是三种基本的介质流,它们分别从Byte数组, StringBuffer, 和本地文件中读取数据,PiperInputStream是从与其他线程公用的管道中读取数据,.

3,ObjectInputStream和所有FileInputStream的子类都是装饰流(装饰器模式的主角).

 

2,输出字节流OutputStream

IO中输出字节流的继承图可以看出:

1,OutputStream是所有的输出字节流的父类, 它是一个抽象类.

2,ByteArrayOutputStream, FileOutputStream是两种基本的介质流,它们分别向Byte数组和本地文件中写入数据.PipedOutputStream是向其它线程公用的管道中子写入数据.

3,ObjectOutputStream和所有FileOutputStream的子类都是装饰流.

 

 

3,字符输入流Reader

1,Reader是所有的输入字符流的父类,它是一个抽象类.

2,CharReader, StringReader是两种基本的介质流,它们分别将Char数组,String中读取数据,PipedReader是从与其它线程共用的管道中读取数据.

3,BufferReader很明显就是一个装饰器,它和子类负责装饰其它Reader对象.

4,FileReader是所有自定义具体装饰流的父类,其子类PushbackReader对Reader对象进行装饰,会增加一个行号.

5,InputStreamReader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流. FileReader可以说是一个达到此功能,常用的工具类, 在其源代码中明显是用了将FileInputStream转变为Reader的方法. 我们可以将这个类中得到一定的技巧. Reader中各个类的用途和使用方法基本和InputStream中的类使用一致.后面会有Reader与InputStream的对应关系.

 

4,字符输出流Writer

1,Writer是所有的输出字符流的父类,它是一个抽象类.

2,CharArrayWriter, StringWriter是两种基本的介质流, 它们分别向Char数组, String中写入数 据.PiperWriter

3,BufferedWriter是一个装饰器为Writer提供缓冲功能.

4,PrintWriter和PrintStream及其类似,功能和使用也非常相似.

5,OutputStreamWriter是OutputStream到Writer转换的桥梁,它的子类FileWriter其实就是一个实现此 功能的具体类(具体可以研究---SourceCode).功能和使用OutputStream极其相似.

 

 

5,字符流与字节流转换

转换流的特点:

1,它是字符流和字节流之间的桥梁.

2,可对读取到的字节数据经过指定编码转换成字符.

3,可对读取到的字符数据经过指定编码转换成字节.

如何使用转换流?

1,当字节和字符之间有转换动作时.

2,流的数据需要编码或解码时.

具体的对象体现:

1,InputStreamReader. 字节到字符的桥梁.

2,OutputStreamWriter. 字符到字节的桥梁.

这两个流对象是字符体系中的成员.它们有转换作用,本身又是字符流.所以在构造的皇后需要传入字节流对象进来.

 

6,File类

File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹.File类保存文件或者目录的各种元数据信息, 包括文件名,文件长度,最后修改时间,是否可读,获取当前文件的路径名,判断指定文件是否存在,获得当前目录中的文件列表.创建,删除文件和目录等方法.

 

7,RandomAccessFile类

该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据,该对象特点:

1,该对象只能操作文件,所以构造函数接收两种类型的参数:a字符串文件路径; b,File对象.

2,该对象即可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r, nv).

注意: 该对象在进行实例化时,如果要操作的文件不存在,会自动创建;如果文件存在,写数据未指定位置,会从头开始写,即覆盖原有的内容.可以用于多线程下载或多个线程同时写数据到文件.

 



File类--使用[Io01.java]

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * File类的基本用法
 */
import java.io.*;//必需加载IO包
public class Io01 {
	public static void main(String[] args) {
		//创建一个文件对象
		File f1=new File("e:\\aa.txt");
		//得到文件的路径
		System.out.println("文件路径"+f1.getAbsolutePath());
		//得到文件的大小,字节数
		System.out.println("文件的大小"+f1.length());
		
		//创建文件夹
		File f3=new File("e:\\ff");
		//判断文件夹是否存在
		if(f3.isDirectory()){
			System.out.println("文件夹存在，不能创建!");
		}else{
			//创建文件夹
			f3.mkdir();
		}

		//创建文件和创建文件夹
		File f2=new File("e:\\ff\\hsp.txt");
		//判断文件是否存在
		if(!f2.exists()){
			//可以创建
			try {
				f2.createNewFile();//创建一个新文件
			} catch (Exception e) {
				e.printStackTrace();
			}
			
		}else{
			System.out.println("文件存在，不能创建!");
		}
		
		//列出一个文件夹下面的所有文件
		File f4=new File("e:\\ff");
		//判断文件夹是事存在
		if(f4.isDirectory()){
			//将文件夹的文件，传给lists数组
			File lists[]=f4.listFiles();
			//遍历数组
			for(int i=0;i<lists.length;i++){
				//输出文件夹下所有文件文件名
				System.out.println("显示出文件名是"+lists[i].getName());
			}
		}
	}
}</span></span>

java文件编程--常用io流

常用io流--文件字节流

1、案例[Io02.java]：读取文件(文件字节输入流使用，目的：FileInputStream类)把用FileInputStream的对象把文件读入到内存

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * File类的基本用法
 * io流--文件字节流
 * FileInputStream类的使用
 */
import java.io.*;
public class Io02 {
	public static void main(String[] args) {
		//得到一个文件对象，f指向e:\ff\hsp.txt文件
		File f=new File("e:\\ff\\hsp.txt");
		FileInputStream fis=null;
		try {
			//因为File没有读写的能力，所以需要使用InputStream类
			fis=new FileInputStream(f);
			//定义一个字节数组，相当于缓存
			byte []bytes=new byte[1024];
			int n=0;//得到实际读取到的字节数
			//循环读取
			while((n=fis.read(bytes))!=-1){
				//把字节转成String
				String s=new String(bytes,0,n);
				System.out.println(s);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//关闭文件流必需放在finally语句块中
			try {
				fis.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}</span></span>

2、案例[Io03.java]：从键盘接收用户输入内容，并保存到文件中(文件字节输出流，目的：FileOutputStream类)

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * File类的基本用法
 * io流--文件字节流
 * FileOutputStream类的使用
 */
import java.io.*;
public class Io03 {
	public static void main(String[] args) {
		File f=new File("e:\\ff\\ss.txt");//直接覆盖写同一个文件
				//字节输出流
		FileOutputStream fos=null;
		if(f.exists()){
			System.out.println("文件已存在");
		}else{
			try {
				fos=new FileOutputStream(f);
				String s="hello,world!\r\n";
				String s1="中国人";
				fos.write(s.getBytes());
				fos.write(s1.getBytes());
			} catch (Exception e) {
				e.printStackTrace();
			}finally{
				try {
					fos.close();
				} catch (Exception e2) {
					e2.printStackTrace();
				}
			}
		}
	}
}</span></span>

3、案例[Io04.java]：图片拷贝

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * File类的基本用法
 * io流--文件字节流
 * 图片拷贝--FileInputStream类与 FileOutputStream类
 */
import java.io.*;
public class Io04 {
	public static void main(String[] args) {
		//先将图片读入到内存，再将内存中的图片写入到某个文件
		//因为二进制文件只能拿使用字节流来处理
		//输入流
		FileInputStream fis=null;
		//输出流
		FileOutputStream fos=null;
		
		try {
			fis=new FileInputStream("e:\\ff\\a.jpg");
			fos=new FileOutputStream("e:\\a.jpg");
			byte buf[]=new byte[1024];
			int n=0;//记录实际读取到的字节数
			//循环读取图片
			while((n=fis.read(buf))!=-1){
				//输出到指定文件
				fos.write(buf);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			//一定要关闭打开的文件流
			try {
				fis.close();
				fos.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}</span></span>

java文件编程--常用io流

常用io流--文件字符流

案例[Io05.java](文件字符输入、输出流，目的：FileReader、FileWriter类)读取一个文件并写入到另一个文件中char[]来中转

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * File类的基本用法
 * io流--文件字符流，只能用于完全为字符的文件
 * TXT文件拷贝--FileReader类与 FileWriter类
 */
import java.io.*;
public class Io05 {
	public static void main(String[] args) {
		//文件取出字符流对象(输入流)
		FileReader fr=null;
		//写入到文件(输出流)
		FileWriter fw=null;
		try {
			//创建fr对象
			fr=new FileReader("e:\\ff\\hsp.txt");
			//创建输出对象
			fw=new FileWriter("e:\\hsp.txt");
			//创建字符数组
			char c[]=new char[1024];
			int n=0;
			//读入到内存
			while((n=fr.read(c))!=-1){
				//控制台输出TXT文件内容
				String s=new String(c,0,n);
				System.out.println(s);
				fw.write(c, 0, n);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				fr.close();
				fw.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}</span></span>

常用io流--缓冲字符流

为了提高效率引入了缓冲字符流

案例[Io06.java](文件缓冲字符流，目的：BufferedReader和BufferedWriter类介绍，直接操作String)

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * File类的基本用法
 * io流--缓冲字符流
 * BufferedReader类与BufferedWriter类
 */
import java.io.*;
public class Io06 {
	public static void main(String[] args) {
		BufferedReader br=null;
		BufferedWriter bw=null;
		try {
			//先创建FileReader对象
			FileReader fr=new FileReader("e:\\ff\\hsp.txt");
			br=new BufferedReader(fr);
			
			//创建FileWriter对象
			FileWriter fw=new FileWriter("e:\\hsp1.txt");
			bw=new BufferedWriter(fw);
			
			//循环读取
			String s="";
			while((s=br.readLine())!=null){
				//输出到磁盘
				bw.write(s+"\r\n");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				br.close();
				bw.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}</span></span>

常用io流—缓冲字节流BufferedInputStream

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">import java.io.*;

public class BufferedStreamTest01 {
	public static void main(String[] args) {
		InputStream is = null;
		OutputStream os = null;
		try {
			is = new BufferedInputStream(new FileInputStream("c:\\test.txt"));
			os = new BufferedOutputStream(new FileOutputStream(
					"d:\\test.txt.bak"));
			int b = 0;
			while ((b = is.read()) != -1) {
				os.write(b);
			}
			// 手动调用flush，将缓冲区中的内容写入到磁盘
			// 也可以不用手动调用，缓存区满了自动回清楚了
			// 而当输出流关闭的时候也会先调用flush
			os.flush();
			System.out.println("文件复制完毕！");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (os != null) {
					// 在close 前会先调用flush
					os.close();
				}
			} catch (IOException e) {
			}
		}
	}
}</span></span>

常用io流--打印输出流PrintWriter

打印输出流PrintWriter可以使用print/println及writer方法。但不换行。需在文本内容中加入\r\n通配符才可以做到。

PrintWriter的使用方法与FileReader、FileWriter/BufferedReader、BufferedWriter基本相同

 

记事本实例[Io07.java]

<span style="font-size:18px;"><span style="font-size:18px;color:#333333;">/**
 * 我的记事本(界面+功能)
 */
import java.awt.*;
import javax.swing.*;
import java.io.*;
import java.awt.event.*;
public class Io07 extends JFrame implements ActionListener{
	//定义组件
	JTextArea jta=null;//文本框
	//菜单条
	JMenuBar jmb=null;
	//定义第一个JMenu
	JMenu jm1=null;
	//定义JMenuItem
	JMenuItem jmi1=null;
	JMenuItem jmi2=null;
	JMenuItem jmi3=null;
	
	public static void main(String[] args) {
		Io07 io=new Io07();
	}
	//构造函数
	public Io07(){
		//创建组件
		jta=new JTextArea();
		jmb=new JMenuBar();
		jm1=new JMenu("文件(F)");
		//设置助记符
		jm1.setMnemonic('F');
		jmi1=new JMenuItem("打开(O)");
		//open打开注册监听
		jmi1.addActionListener(this);
		jmi1.setActionCommand("open");
		
		jmi2=new JMenuItem("保存(S)");
		//save保存注册监听
		jmi2.addActionListener(this);
		jmi2.setActionCommand("save");
		
		jmi3=new JMenuItem("退出(X)");
		//exit退出注册监听
		jmi3.addActionListener(this);
		jmi3.setActionCommand("exit");
		
		//加入到菜单
		this.setJMenuBar(jmb);
		//把jm1放到jmb
		jmb.add(jm1);
		//把 jmi1放入jm1
		jm1.add(jmi1);
		jm1.add(jmi2);
		jm1.add(jmi3);
		
		//设置界面管理器(默认BorderLayout边界布局管理器)
		
		//加入组件
		this.add(jta);
		
		//设置JFrame面板
		this.setTitle("记事本界面与功能");
		this.setSize(500, 400);
		this.setLocationRelativeTo(null);
		this.setVisible(true);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	
	public void actionPerformed(ActionEvent e) {
		//判断"打开"菜单被选中
		if(e.getActionCommand().equals("open")){
			/**
			 * 隆重推荐JFileChooser组件
			 */
			//创建一个文件选择组件
			JFileChooser jfc=new JFileChooser();
			//设置名字
			jfc.setDialogTitle("请选择要打开的文件...");
			//使用默认方式
			jfc.showOpenDialog(null);
			//显示
			jfc.setVisible(true);
			
			//得到用户选择的文件全(绝对)路径
			String filename=jfc.getSelectedFile().getAbsolutePath();
			
			FileReader fr=null;
			BufferedReader br=null;
			try {
				fr=new FileReader(filename);
				br=new BufferedReader(fr);
				//从文件中读取信息并显示到jta(JTextArea)中
				String s="";
				String allCon="";
				while((s=br.readLine())!=null){
					allCon+=s+"\r\n";//"\r\n"显示文本时将文件中原有的格式显示到jta中
				}
				//放置到jta即可
				jta.setText(allCon);
			} catch (Exception e2) {
				e2.printStackTrace();
			}finally{
				try {
					br.close();
					fr.close();
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}//判断"保存"菜单被选中
		}else if(e.getActionCommand().equals("save")){
			//创建保存对话框
			JFileChooser jfc=new JFileChooser();
			//设置名字
			jfc.setDialogTitle("将文件保存到...");
			//使用默认方式
			jfc.showSaveDialog(null);
			//显示
			jfc.setVisible(true);
			
			//得到用户希望把文件保存到何处，文件全路径
			String file=jfc.getSelectedFile().getAbsolutePath();
			
			//准备写入到指定文件
			FileWriter fw=null;
			BufferedWriter bw=null;
			try {
				fw=new FileWriter(file);
				bw=new BufferedWriter(fw);
				//将JtextArea中的内容输出到指定文件中
				bw.write(this.jta.getText());
			} catch (Exception e2) {
				e2.printStackTrace();
			}finally{
				try {
					bw.close();
					fw.close();
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
			
		}else if(e.getActionCommand().equals("exit")){
			System.exit(0);
		}
	}
}
</span></span>


本内容遵循 CC 4.0 BY-SA 版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
2019-7-17 [JavaSE] 文件字节流 练习题2个 文章目录1. txt写入2. map3文件的复制 1. txt写入 任务一： 文件字节流： 一个字符串 “helloword”,使用文件字节流，把其中的word写入文件word.txt中。 难点：write(参数,参数,参数) public class homework1 { public static void main(String[] args) throws IOException { ... 阅读详情

相关推荐

JavaSE---IO流（字节流、转换流、字符流）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Oner.wv的专栏 1119

Java基础：IO流之字节流和字符流

一、流的概念流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出

JackChan 1万+

【黑马程序员】---- Java 基础之 学习使用API文档

在工作过程中，难免会遇到自己未接触过的知识或技术，而一款成熟的产品，并将有配套的API手册供用户查看，有的还附带有Demo。由此，阅读API的能力也间接体现了自学的能力。         Java API 常用类及注意事项：     1、String.         -- boolean equals()   实际工作中，常用在判断参数。 注意，最好将要比较的值放在前面。如 "abc

a872728984的专栏 1038

零基础自学javase黑马课程第十六天

🔮本文由京与旧铺原创，csdn首发！😘系列专栏：java学习💻首发时间：🎞2022年11月21日🎠🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦🎧作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲。

qq_46272491的博客 1184

黑马程序员——JAVASE基础语法

JAVASE基础语法包括: 关键字 标识符 注释 常量、进制和进制转换 变量 数据类型和类型转换 运算符 语句 关键字概述: 被Java语言赋予特定含义的单词 关键字特点: 组成关键字的字母全部小写 标识符概述 就是给类,接口,方法,变量等起名字时使用的字符序列 组成规则 英文大小写字母 数字字符 $和_ 注意事项 不能以数字开头 不能是Java中的关键字

ttuzanhua的博客 381

十六、网络编程【黑马JavaSE笔记】

本文是博主自学b站黑马Java教程总结的笔记，本节对java中的网络编程做了介绍

BoBooY的Java学习笔记 1082

我的JAVASE笔记（黑马ai）

d . 一个类实现了多个接口，如果多个接口中存在同名的默认方法，可以 不冲突，这个类重写该方法即可。c . 一个类继承了父类，又同时实现了接口，如果父类中和接口中有同名 的默认方法，实现类会。，父类就 定义成抽象方法，交给子类去重写实现，我们抽出这样的抽象类，就是为了。

gwq2098321904的博客 2045

JavaSE超详细笔记-网络编程篇-基于黑马

1.1 概念在网络通信协议下，不同计算机上运行的程序，进行的数据传输。即时通信、网游对战、金融证券、国际贸易、邮件、等等。不管是什么场景，都是计算机跟计算机之间通过网络进行数据传输Java中可以使用java.net包下的技术轻松开发出常见的网络应用程序。

超级苦力怕的博客 1217

JavaSE——Java基础语法（黑马个人听课笔记）

常量：在程序的执行过程中，其值不会发生改变的量（数据）进制：指进位制，是人们规定的一种进位方式，表示某一位置上的数，运算时是逢X进一位。十进制是逢十进一，二进制就是逢二进一，八进制是逢八进一...常见进制：二进制，八进制，十进制，十六进制计算机中存储数据的单位：字节（每一个字节，在计算机底层，都是以上二进制的形式进行体现的。十进制运算规则：逢十进一，借一当十。二进制介绍：二进制数据是用0和1两个数码来表示。例如：0101000（进位规则是“逢二进一”，借位规则是“借一当二”。

2301_80760643的博客 1051

黑马程序员 JavaSE-02 Java基础语法1：基本概念

Java基础语法关键字关键字概述 被Java语言赋予特定含义的单词 关键字特点 组成关键字的字母全部小写 关键字注意事项 goto和const作为保留字存在,目前并不使用关键字列表用于定义数据类型的关键字 byte, short, int, long, float, double, char, boolean, void, class, interface, void 用于定义数据类型

ClimberRobert的博客 878

黑马程序员-javaSE学习之语言基础

------- android培训、java培训、期待与您交流！ ----------

月夜@__@流觞 770

黑马程序员-----Java基础知识

【黑马程序员】JAVASE基础知识整理笔记

cui1kcan2的博客 676

黑马程序员_JavaSE基础02 之 进制数 变量 类型转换

----------------------        android培训、java培训、期待与您交流！   ---------------------- JavaSE_02  笔记                                        Java语言基础之 进制数 变量 类型转换 1、Java语言基础组成     关键字；标识符；注释；常量和变量；运算符

535

黑马程序员 JavaSE-07 常用类

java 常用类

ClimberRobert的博客 398

黑马程序员JavaWeb学习笔记 - 3（原理和高级部分）

本文分享了一位计算机专业学生的Java学习笔记，重点介绍了SpringBoot的核心原理。内容包括：配置文件的优先级顺序（命令行参数>系统属性>properties>yml>yaml）；Bean管理的三种获取方式及作用域设置（单例/非单例）；第三方Bean的配置方法；以及SpringBoot的核心优势——通过起步依赖简化版本管理，自动配置减少开发工作量。笔记采用简洁实用的风格，并提供了配套的飞书文档链接供参考学习。

2301_80463485的博客 866

黑马程序员-基础部分（1

--------------------android培训、java培训、期待与您交流！ -------------------- j2ee,j2se,j2me (中2的意思是版本2.0)，5.0之后更名为JAVAEE,JAVASE,JAVAME, java的版本1.0/ 1.1 / 1.2 / 1.3 / 1.4 / 5.0 /6.0 /*2012年4月30日19:42:32 hell

我要我的滋味。 1624

黑马程序员--总结日志1

---------android培训、java培训、期待与您交流！ ----------       Java 命令行方式常见命令：        dir：列出当前目录下的文件以及文件夹                    rd：删除目录        md：创建目录                                                    cd  打开目

Continue. 1186

黑马程序员_java学习体会

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 从接触java到现在有一年多了,但真正开始学习java的时间只有一个多月的时间，在这一个多月的时间，我学习了传智播客的毕向东老师的的java基础视频，毕老师讲课诙谐生动有趣，一下子就吸引了我，我也因此得以对Java有了全新的认识，在这一个多月的时间里，分四个阶段

小胡的博客 1216
上一篇： 黑马程序员_JavaSE基础知识总结十五：反射
下一篇： 黑马程序员_JavaSE基础知识总结十七：GUI界面
点赞 0
评论 0
书签 书签 0
liulin90
liulin90
博客等级 码龄11年 3粉丝 19原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值