String字符串
String是一个类，属于数据类型中的引用类型。
Java中一切使用""引起来的内容，都是这个类的实例，称为字符串对象。
字符串在定义后，值不可改变，是一个常量，实际是一个字符数组。
//这句话执行时，创建一个"Tom"字符串对象，将其地址保存在变量name中
String name = "Tom";
//这句话执行看似在改变字符串的值，实际是创建了一个新的"Jerry"字符串对象，将其地址保存到变量name中
name = "Jerry";
//以上两句，在内存中，会有两个字符串对象"Tom"和"Jerry",没有任何字符串发生了改变，只是name引用了不同的字符串地址
//字符串可以当做数组使用
String str1 = "hello";
//字符串对象实际是一个字符数组对象"包装"而来
char[] list = {'h', 'e', 'l', 'l', 'o'};
String str2=new String(list);
System.out.println(str1);
System.out.println(str2);
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X5zDEXi3-1669982231934)(F:\221001\笔记\JavaAdv01.assets\image-20221123092957257.png)]
String类使用时注意
右上方案例可见，如果频繁地将一个String类型变量的值进行更改时，会创建很多字符串对象。效率低，浪费内存空间。
所以在频繁更改字符串时，不要使用String类变量。
System.out.println("开始执行");
String str = "";
//5万次的循环，就会创建5万个字符串对象，但最终只会有一个字符串对象被str引用
for (int i = 0; i < 50000; i++) {
str += i;
}
System.out.println("执行结束");
如果要频繁更改字符串，使用StringBuilder类或StringBuffer类
如何创建字符串对象
1.使用""赋值创建
String str="abc";
2.通过构造方法创建
| 常用构造方法 | 说明 |
|---|---|
| String() | 创建一个空白字符串对象。 |
| String(String str) | 创建一个指定字符串的字符串对象。 |
| String(char[] list) | 创建一个指定字符数组的字符串对象。 |
| String(byte[] list,String charsetName) | 按指定的编码格式创建一个指定字节数组的字符串对象。 |
不同方式创建字符串的过程
使用""赋值的形式创建
//这句话执行时，先判断字符串常量池(缓冲区)中是否存在"ab",不存在则创建，将其地址保存到str1变量中
String str1 = "ab";
//这句话执行时，先判断字符串常量池(缓冲区)中是否存在"ab",已存在，不用创建，将其地址保存到str2变量中
String str2 = "ab";
//这句话执行时,+两端如果都是""定义的字符串，拼接后再判断字符串常量池(缓冲区)中是否存在
//拼接后的"ab"依然存在，将其地址保存到str3变量中
String str3 = "a" + "b";
//以上三句话，只会在内存中的字符串常量池(缓冲区)创建一个字符串对象"ab"，分别引用给3个变量
System.out.println(str1==str2);//true
System.out.println(str1==str3);//true
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9CIeam5I-1669982231935)(F:\221001\笔记\JavaAdv01.assets\image-20221123100225789.png)]
可以使用Jdk中自带的反编译工具javap对class文件进行反编译
在class文件所在目录下(项目的Out目录中)，进入控制台，输入javap -c 字节码文件名.class
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nUIeHAje-1669982231935)(F:\221001\笔记\JavaAdv01.assets\image-20221123100558302.png)]
使用构造方法String(String str)创建
//这句话执行时的流程
//1.在字符串常量池中寻找"ab",不存在,创建
//2.在堆中new String(),将字符串常量池中的"ab"保存到new出来的区域
//3.将堆中new出来的地址保存到栈中变量str1中
String str1 = new String("ab");
//这句话执行时的流程
//1.在字符串常量池中寻找"ab",存在,直接引用
//2.在堆中new String(),将字符串常量池中的"ab"保存到new出来的区域
//3.将堆中new出来的地址保存到栈中变量str2中
String str2 = new String("ab");
//由于str1和str2是堆中的两个区域，所以结果为false
System.out.println(str1 == str2);//false
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3TfG7KNg-1669982231936)(F:\221001\笔记\JavaAdv01.assets\image-20221123102449165.png)]
使用+拼接""和new出来的字符串对象创建
//在字符串常量池中创建"ab"
String str1 = "ab";
//1.创建StringBuilder对象
//2.在字符串常量池中创建"a"
//3.在字符串常量池中创建"b"
//4.创建String对象
//5.调用StringBuilder的append方法，将"a"和new String("b")拼接
String str2 = "a" + new String("b");//一共创建了"a","b",String,StringBuilder这四个对象
//两个不同的地址
System.out.println(str1==str2);//false
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WxYqZrc3-1669982231936)(F:\221001\笔记\JavaAdv01.assets\image-20221123104555028.png)]
总结
在使用字符串时，如果要比较其值是否相同，不要使用判断，因为判断的是内存地址。
所以在比较字符串是否相同时，要使用String类重写的equals方法进行判断。
该方法判断的原理大致为：将两个字符串用字符数组保存，逐个判断字符数组中的每个字符，全部一致时返回true，
所以比较的是字面值。在使用equals方法时，通常将已知的非空字符串作为调用者。
username.equals("admin");//这样写，username变量可能为空，会抛出空指针异常
"admin".equals(username);//这样写能避免空指针异常
字符串相关面试题
//题目一
String str1 = "ab";//常量池中创建"ab"
String str2 = new String("ab");//堆中new String()保存常量池中已有的"ab"
String str3 = "a" + "b";//用常量池已有的"ab"
String str4 = "a" + new String("b");//常量池中创建"a"和"b",堆中new String()和new StringBuilder()
String str5 = "ab";//用常量池已有的"ab"
System.out.println(str1 == str2);//false
System.out.println(str1 == str3);//true
System.out.println(str1 == str4);//false
System.out.println(str1 == str5);//true
//题目二
//这两句话执行后，会创建几个对象
String s1 = "abc";
String s2 = "a" + "b" + "c";
//在字符串常量池中创建一个对象"abc"
//题目三
//这两句话执行后，会创建几个对象
String s3 = new String("你好");//常量池："你好",堆中:new String()
String s4 = new String("你好");//堆中:new String()
//3个对象：堆中两个new String()，常量池中"你好"
//题目四
//这两句话执行后，会创建几个对象
String s5 = "hello";//常量池："hello"
String s6 = "hel" + new String("lo");//常量池:"hel"和"lo" 堆:new String()和new StringBuilder
//5个对象：常量池："hello"、"hel"和"lo"，堆:new String()和new StringBuilder
//题目五
String s7 = new String("wor");//常量池："wor"，堆：new String()
String s8 = s7 + "ld";//常量池："ld" 堆：new StringBuilder()
//4个对象：常量池：”wor"和"ld"，堆：new String()和new StringBuilder
字符串String类中的常用方法
| 方法名 | 返回值 | 作用 |
|---|---|---|
| length() | int | 得到字符串的长度 |
| toLowerCase() | String | 转换为小写 |
| toUpperCase() | String | 转换为大写 |
| trim() | String | 去除字符串首尾的所有空格 |
| isEmpty() | boolean | 判断字符串是否为空白字符串"" |
| getBytes() | byte[] | 将字符串转换为字节数组 |
| toCharArray() | char[] | 将字符串转换为字符数组 |
| equalsIgnoreCase(String str) | boolean | 忽略大小写判断两个字符串是否相同 |
| equals(String str) | boolean | 判断两个字符串是否相同 |
| charAt(int index) | char | 得到字符串指定索引上的字符 |
| indexOf(String str) | int | 得到字符串中某个子字符串第一次出现的索引，如果不存在，返回-1 |
| lastIndexOf(String str) | int | 得到字符串中某个子字符串最后一次出现的索引，如果不存在，返回-1 |
| contains(字符序列) | boolean | 判断某个子字符串是否在原字符串中出现 |
| concat(String str) | String | 将参数字符串拼接到原字符串末尾 |
| startsWith(String str) | boolean | 判断是否以指定字符串开头 |
| endsWith(String str) | boolean | 判断是否以指定字符串结尾 |
| substring(int begin) | String | 从指定索引开始截取字符串至末尾 |
| substring(int being,int end) | String | 截取[begin,end)区间内的字符串 |
| split(String regex) | String[] | 按执行字符串或正则表达式切分原字符串。如果指定内容不再末尾，n个指定字符能得到n+1个子串;如果指定内容在末尾，n个指定字符能得到n个子串(不包含末尾的无效字符) |
| replace(char oldChar,char newChar) | String | 将原字符串中的所有指定字符替换为新字符 |
| String.valueOf(参数) | String | 将任意参数转换为字符串。通常用于原始类型转换为字符串。 |
| String.formart(String 格式,Object… obj) | String | 根据指定格式转换参数。常用于将浮点数保留小数。如String.format(“%4.2f”,10.0/3)表示将计算的结果四舍五入保留2位小数转换为字符串；如果最终数据所占位置小于4，原样输出，大于4在最前补充空格。 |
可变字符串
String字符串对象是一个常量，在定义后，值不可改变。
如果使用String类的对象，对其频繁更新时，就会不停地创建新的对象，不停引用给同一个变量。
如要执行10000次循环重新赋值的过程，就要创建10000个字符串对象，执行效率很低，这时就需要使用可变字符串对象。
package com.hqyj.StringBuilderTest;
/*
* 可变字符串StringBuilder
* */
public class Test1 {
public static void main(String[] args) {
System.out.println("程序开始执行");
//System.currentTimeMillis();用于获取当前时间对应的毫秒数
//从1970 1 1 0:0:0这一刻开始，到这句话执行时间隔的毫秒数
long startTime = System.currentTimeMillis();
/*
//循环"更新"字符串，实际是在不停创建新的字符串
String str = "";
for (int i = 0; i < 50000; i++) {
str += i;
}*/
//使用可变字符串StringBuilder对象，真正更新字符串
//因为全程只有一个对象StringBuilder，每次循环只是在不停操作该对象，不会创建新对象，所以效率很高
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 500000; i++) {
sb.append(i);
}
long endTime = System.currentTimeMillis();
System.out.println("程序执行结束,用时" + (endTime - startTime) + "毫秒");
}
}
StringBuilder类
用于表示可变字符串的一个类，是非线程安全的，建议在单线程环境下使用。
StringBuffer类
用于表示可变字符串的一个类，是线程安全的，建议在多线程环境下使用。
StringBuilder和StringBuffer中的方法都一致，只不过StringBuffer中的方法使用了synchoronized关键字修饰，表示是一个同步方法，在多线程环境下不会出现问题。
这里以StringBuilder为例
构造方法
| 常用构造方法 | 作用 |
|---|---|
| StringBuilder() | 创建一个大小为16的字符串数组，表示一个空白字符。类似于String str=“”; |
| StringBuilder(String str) | 创建一个str长度+16的字符数组后，将str添加到其中。类似于String str=“初始值”; |
普通方法
| 常用方法 | 作用 |
|---|---|
| append(Object obj) | 将任意类型的参数添加到原可变字符串末尾 |
| delete(int start,int end) | 删除[start,end)区间内的字符 |
| deleteCharAt(int index) | 删除index索引上的字符 |
| insert(int index,Object obj) | 在索引index上插入obj |
| replace(int start,int end,String str) | 将[start,end)区间内的字符替换为str |
| reverse() | 反转字符串 |
注意
- 以上表格中的方法都是在直接操作同一个字符串对象，每次调用方法后，原字符串都会发生变化
- StringBuffer和StringBuilder并没有重写equals方法，所以可变字符串的值是否相同时，调用的是equals中原始的==判断。如果要判断两个可变字符串的值是否相同时，需要将其转换为String后调用equals判断
可变字符串与String之间的转换
String转换为可变字符串
String str="hello";
//通过构造方法将String"包装"为可变字符串对象
StringBuilder sb = new StringBuilder(str);
可变字符串转换为String(任意类型对象转换为String)
方法一：String.valueOf(Object obj)方法
StringBuilder sb = new StringBuilder("你好");
//调用静态方法
String str = String.valueOf(sb);
方法二：对象.toString();
StringBuilder sb = new StringBuilder("你好");
//调用toString()
String str = sb.toString();
方法三：
StringBuilder sb = new StringBuilder("你好");
//拼接一个空字符串
String str = sb + "";
可变字符串面试题
比较String、StringBuilder和StringBuffer的区别
相同点：
- 这三个类都可以表示字符串。都提供了一些操作字符串的方法。
- 这三个类中有相同的方法，如charAt()、indexOf()等
- 这三个类都是被final修饰的类，不能被继承
不同点：
- String定义的字符串是一个常量。可变字符串定义的字符串是一个变量
- String类中的方法，调用后，不会改变原本字符串的值；可变字符串类中的方法，调用后，会改变原本字符串的值
- StringBuilder是非线程安全的可变字符串类，StringBuffer是线程安全的可变字符串类，其中的方法被synchronized修饰
总结
在频繁操作同一个字符串时，一定要使用可变字符串StringBuidler或StringBuffer类的对象，不能使用String类的对象。
System类
这个类中包含了一些系统相关的信息和一些方法。其中的属性和方法都是静态的。
该类不能创建对象，不是因为它是一个抽象类，而是因为它的构造方法是私有的。
| 常用属性和方法 | |
|---|---|
| System.out | 获取打印输出流PrintStream对象，用于控制台打印信息。 |
| System.in | 获取输入流InputStream对象，用于获取输入的信息 |
| System.err | 获取打印输出流PrintStream对象，用于控制台打印异常信息。 |
| System.exit(int statues) | 终止虚拟机运行，参数0表示正常终止。 |
| System.currentTimeMillis() | 获取从1970.1.1 0:0:0至今进过了多少毫秒。中国是UTC(+8)，所以是从1970.1.1 8:0:0至今经过了多少毫秒。返回long类型。 |
| System.arraycopy(原数组,原数组起始位置,目标数组,目标数组起始位置,原数组要复制的元素数量) | 将原数组中指定长度的元素复制到新数组中 |
RunTime类
Runtime类的对象，表示程序运行时对象(程序运行环境对象)。
包含了程序运行环境相关的信息。常用于获取运行环境信息(如虚拟机内存)或执行某个命令。
特点
这个类不是一个抽象类，但不能创建对象，因为它的构造方法是私有的。
这个类提供了一个静态方法getRuntime()，通过这个方法，可以获取一个Runtime类的对象。
这是Java中的一种设计模式–单例模式(一个类只能有一个创建对象)。
public class Runtime {
//定义了私有的一个静态成员：当前类的对象
//由于静态成员只在类加载时执行一次，所以这里只会创建唯一一个当前类的对象
private static Runtime currentRuntime = new Runtime();
//定义了一个公共的静态方法，用于获取创建的唯一的当前类的对象
public static Runtime getRuntime() {
return currentRuntime;
}
//构造方法是私有的，不能在当前类之外创建对象
private Runtime() {}
}
使用
package com.hqyj.test;
import java.io.IOException;
public class RuntimeTest {
public static void main(String[] args) throws IOException, InterruptedException {
//通过Runtime类的静态方法getRuntime()获取唯一的Runtime类的实例
Runtime runtime = Runtime.getRuntime();
System.out.println("当前虚拟机空闲内存" + runtime.freeMemory() / 1024 / 1024 + "MB");
System.out.println("当前虚拟机实际最大内存" + runtime.totalMemory() / 1024 / 1024 + "MB");
System.out.println("当前虚拟机支持的最大内存" + runtime.maxMemory() / 1024 / 1024 + "MB");
//exec(String 指令名)运行某个指令，返回运行的进程对象
//在指定秒后关机
// Process process = runtime.exec("shutdown -s -t 300");
//取消关机任务
// Process process = runtime.exec("shutdown -a");
//mspaint画图 calc计算器 notepad记事本
Process process = runtime.exec("mspaint");
Thread.sleep(2000);
//通过进程对象调用销毁功能，从而关闭
process.destroy();
}
}
方法调用时传值问题
package com.hqyj.test2;
public class Test {
/*
* 当方法的参数为原始类型，方法中对该参数做修改，不会影响实际参数
* */
public static void fun1(int i) {
i = 123;
System.out.println(i);
}
/*
* 当方法的参数为字符串时，方法中对字符串"重新赋值"，实际是创建了一个新的字符串对象，不会影响实际参数
* */
public static void fun2(String str) {
str = "new";
System.out.println(str);
}
/*
* 如果参数为引用类型，方法中直接操作该参数，操作的就是实际参数的内存地址，会影响实际参数
* */
public static void fun3(Person p) {
p.setName("吴彦祖");
System.out.println(p.getName());
}
/*
* 如果参数为引用类型，方法中创建了一个新对象对其赋值，操作的是创建的新对象，不会影响实际参数
* */
public static void fun4(Person p) {
p = new Person();
p.setName("易烊千玺");
System.out.println(p.getName());
}
/*
* 如果参数为数组，也属于引用类型，方法中直接操作数组，操作的是实参数组，会影响实际参数
* */
public static void fun5(int[] list) {
list[0] = 123;
System.out.println(list[0]);
}
public static void fun(char[] list,Person p){
list[0]='m';//这里在直接操作实际参数，会影响实参
p = new Person();//这里创建了一个新的对象，操作的是方法中的对象，不会影响实参
p.setName("刘鑫");
}
public static void main(String[] args) {
//方法参数为原始类型，方法中对参数做修改，不会改变实际参数
int i = 0;
fun1(i);//123
System.out.println(i);//0
//方法参数为字符串，方法中对字符串重新赋值，不会改变实际参数
String str = "old";
fun2(str);//new
System.out.println(str);//old
//方法参数为引用类型，方法中对参数直接修改，会改变实际参数
Person p = new Person();
p.setName("王海");
fun3(p);
System.out.println(p.getName());
//方法参数为引用类型，方法中创建新对象后赋值给实际参数，操作的是方法中的对象，不会改变实际参数
Person p1 = new Person();
p1.setName("赵敏");
fun4(p1);
System.out.println(p1.getName());
//方法参数为数组，属于引用类型，方法中对参数直接修改，会改变实际参数
int[] list = {0,1,2};
fun5(list);
System.out.println(list[0]);
//练习
char[] list2={'a','b','c'};
Person p2 = new Person();
fun(list2,p2);
System.out.println(list2[0]);//m
System.out.println(p2.getName());//null
}
}
总结
参数只有是引用类型(类、数组、接口),并且方法中在直接操作该参数时，才会对实际参数造成影响。
fun3(Person p)参数为Person对象，方法中直接调用参数p的xxx方法，是在操作实际参数。
fun5(int[] list)参数为数组，方法中直接操作数组某个索引对应的元素，是在操作实际参数。
fun2(String str)和fun4(Person p)都在方法中创建了一个新的对象，是在操作方法中的参数，不影响实际参数。
public static void fun(char[] list,Person p){
list[0]='m';//这里在直接操作实际参数，会影响实参
p = new Person();//这里创建了一个新的对象，操作的是方法中的对象，不会影响实参
p.setName("刘鑫");
}
public static void main(String[] args){
char[] list={'a','b','c'};
Person p = new Person();
fun(list,p);
System.out.println(list[0]);//方法内部直接操作数组，会影响实际参数，输出m
System.out.println(p.getName());//方法内部创建了新对象，不会影响实际参数，输出null
}
Date类
用于表示日期时间的类，位于java.util包下
构造方法
| 常用构造方法 | 说明 |
|---|---|
| Date() | 创建当前瞬间对应的日期对象 |
| Date(long l) | 创建指定瞬间对应的日期对象 |
| Date(int year,int month,int day) | 该构造方法已过时。创建指定年月日的日期对象(年是1900年起经过的年数，月用0-11表示1到12月) |
常用方法
| 常用方法 | 作用 |
|---|---|
| getTime() | 得到对应Date对象表示的毫秒数 |
| setTime(long l) | 设置Date对象的毫秒数 |
| after(Date when) | 判断调用日期对象是否在when之后 |
| before(Date when) | 判断调用日期对象是否在when之前 |
SimpleDateFormat类
用于格式化日期的类。
构造方法
| 常用构造方法 | 作用 |
|---|---|
| SimpleDateFormat(String pattern); | 创建一个指定日期模板的格式化日期对象 |
日期模板
| 特殊字符 | 作用 |
|---|---|
| yyyy | 年份 |
| MM | 月份 |
| dd | 日期 |
| HH | 小时 |
| mm | 分钟 |
| ss | 秒 |
| E | 星期 |
| 以上两个字母都可以写成一个，如月份5 | M：5，MM：05 |
| yyyy/MM/dd HH:mm:ss E | 2022/11/24 16:24:09 星期四 |
常用方法
| 常用方法 | 返回值 | 作用 |
|---|---|---|
| format(Date date) | String | 将Date对象按日期模板转换为字符串 |
| parse(String str) | Date | 将满足日期模板的字符串转换为Date对象 |
package com.hqyj.test3;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatTest {
public static void main(String[] args) throws ParseException {
//定义格式化日期类所需的时间模板
/*
* yyyy 年
* MM 月份
* dd 日期
* HH 24小时制
* hh 12小时制
* mm 分钟
* ss 秒
* E 星期
*
* 两个字母都可以写成一个，如月份MM和M
* MM 5月实际为05
* M 5月实际为5
* */
String patten = "yyyy/MM/dd HH:mm:ss E";//年/月/日 时:分:秒 星期
//创建格式化日期类对象，参数为日期模板
SimpleDateFormat sdf = new SimpleDateFormat(patten);
//创建当前日期对象
Date now = new Date();
//调用格式化日期对象的format(Date date)，将Date对象转换为指定日期格式的字符串
String format = sdf.format(now);
//输出
System.out.println(format);
//parse(String str)将指定日期模板的字符串转换为Date对象
Date date = sdf.parse("2000/5/3 2:1:3 星期一");
System.out.println(date);
}
}
Calendar类
表示日历的类，包含了很多日历相关的信息。
是一个抽象类，无法创建对象。可以通过静态方法getInstance()获取该类的一个实例。
//获取Calendar类的对象
Calendar cal = Calendar.getInstance();
日历字段
在Calendar类中，定义了很多被final和static修饰的常量，称为日历字段，实际一个数字，用于获取指定信息
| 值 | 作用 |
|---|---|
| Calendar.YEAR | 年份 |
| Calendar.MONTH | 月份(0-11表示1-12月) |
| Calendar.DATE | 日期 |
| Calendar.DAY_OF_WEEK | 星期(1-7表示周天到周六) |
| Calendar.HOUR | 12进制小时 |
| Calendar.HOUR_OF_DAY | 24进制小时 |
| Calendar.MINUTE | 分钟 |
| Calendar.SECOND | 秒 |
| Calendar.DAY_OF_MONTH | 本月第几天 |
| Calendar.DAY_OF_YEAR | 本年第几天 |
| Calendar.WEEK_OF_MONTH | 本月第几周 |
| Calendar.WEEK_OF_YEAR | 本年第几周 |
常用方法
| 常用方法 | 作用 |
|---|---|
| get(int field) | 根据日历字段获取对应的值 |
| getTime() | 获取对应的Date对象(Calendar对象转换为Date对象) |
| getMaximum(int field) | 获取指定日历字段支持的最大值，如Calendar.DATE最大31 |
| getActualMaximum(int field) | 获取指定日历字段在当前日期下的实际最大值，如11月，Calendar.DATE最大30 |
| set(int field,int value) | 将指定的日历字段设置为指定值 |
| set(int year,int month,int date) | 同时设置日历对象的年月日 |
| setTime(Date date) | 将Date对象作为参数设置日历对象的信息 |
实现万年历
package com.hqyj.homework;
import java.util.Calendar;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入年月");
Calendar cal = Calendar.getInstance();
int year = sc.nextInt();
int month = sc.nextInt();
//设置指定年月，默认为1号
cal.set(year, month - 1, 1);
//用于换行的计数，每行7个，包括空格
int count = 0;
System.out.println("========"+year+"年"+month+"月========");
System.out.println("一\t二\t三\t四\t五\t六\t日");
//打印1号前的空格
//DAY_OF_WEEK 星期 空格数量
//2 一 0
//3 二 1
//4 三 2
//5 四 3
//6 五 4
//7 六 5
//1 日 6
//获取本月1号是所在周的第几天
int week = cal.get(Calendar.DAY_OF_WEEK);
//根据规律判断，打印空格的同时也要计数
if (week == 1) {
System.out.print("\t\t\t\t\t\t");
count += 6;
} else {
for (int i = 1; i <= week - 2; i++) {
System.out.print("\t");
count++;
}
}
//遍历当月每一天
for (int i = 1; i <= cal.getActualMaximum(Calendar.DATE); i++) {
System.out.print(i + "\t");
count++;
//隔7换行
if (count % 7 == 0) {
System.out.println();
}
}
}
}
文件类File
Java中的File类，表示本地硬盘中的文件(文件和目录)的一个类。
通过这个类创建的对象，可以操作对应的文件。
构造方法
| 常用构造方法 | 说明 |
|---|---|
| File(String pathName) | 根据文件的完整路径创建File对象 |
| File(String parent,String child) | 根据文件的父目录路径和自身路径创建File对象 |
| File(File parent,String child) | 根据文件的父目录对应的File对象和自身路径创建File对象 |
//如想要表示 “F:\221001\笔记\面向对象部分回顾.pdf” 这个文件
//File(String pathName)
File file1 = new File("F:\\221001\\笔记\\面向对象部分回顾.pdf");
//File(String parent,String child)
File file2 = new File("F:\\221001\\笔记", "面向对象部分回顾.pdf");
//File(File parent,String child)
File parent = new File("F:\\221001\\笔记");
File file3 = new File(parent, "面向对象部分回顾.pdf");
//file1、file2、file3都表示同一个文件
常用方法
| 常用方法 | 说明 |
|---|---|
| exists() | 判断文件是否存在 |
| isFile() | 判断是否为文件 |
| isDirectory() | 判断是否为目录 |
| getName() | 获取文件名 |
| getPath() | 获取文件相对路径 |
| getAbsolutePath() | 获取文件绝对路径 |
| getParent() | 获取父目录的名称 |
| getParentFile() | 获取父目录对象 |
| lastModified() | 获取最后一次修改时间对应的毫秒数 |
| length() | 获取文件所占字节 |
| isHidden() | 判断文件是否隐藏 |
| delete() | 删除文件或空目录 |
| renameTo(File newFile) | 将原文件重命名且移动到指定目录 |
| mkdir() | 创建目录 |
| list() | 获取某个目录下的第一层子文件的名称的数组 |
| listFiles() | 获取某个目录下的第一层子文件对象的数组 |
斐波那契数列
package com.hqyj.FileTest;
public class Test2 {
public static void main(String[] args) {
//兔子问题
//有一对兔子在第三个月开始，每个月都能生一对小兔子
//如果所有兔子不死亡，且每次生下的都是一雌一雄，问10个月后共有多少对兔子
//1月 2月 3月 4月 5月 6月 7月 8月 9月 10月
//1 1 2 3 5 8 13 21 34 55
//斐波那契数列
//f(n)=f(n-1)+f(n-2) n>2
Test2 t = new Test2();
System.out.println(t.f(20));
}
/*
* 递归方法
* */
public int f(int n) {
if (n > 2) {
return f(n - 1) + f(n - 2);
}
return 1;
}
}
递归遍历文件夹
package com.hqyj.FileTest;
import java.io.File;
import java.util.Date;
public class Test3 {
//查看某个目录下的所有文件
public static void main(String[] args) {
File source = new File("E:\\adobe");
Test3 t = new Test3();
t.fun(source);
}
/*
* 递归遍历文件夹
* */
public void fun(File source) {
//输出某个目录中超过3个月未使用且大于500MB的文件
/*
long start = source.lastModified();
long end = System.currentTimeMillis();
if ((end - start) / 1000 / 3600 / 24 > 90 && source.length() / 1024 / 1024 > 500) {
System.out.println(source.getName() + "\t" + new Date(source.lastModified()) + "\t" + source.length() / 1024 / 1024);
}*/
//判断是否为目录
if (source.isDirectory()) {
//将其展开
for (File child : source.listFiles()) {
//因为子文件有可能是目录，继续调用本方法
fun(child);
}
}
}
}
IO
I：Input输入
O：Output输出
流Stream
在Java中，流用于表示计算机硬盘与内存之间传输数据的通道。
将内存中的数据存入到硬盘中，称为写write，也称为输出Output。
将硬盘中的数据存入到内存中，称为读read，也称为输入Input。
流的分类
Java中将流定义为类，以对象的形式表现流。流有"四大家族"，是所有流的父类。
字节输入流InputStream
FileInpuStream、ObjectInputStream
字节输出流OutputStream
FileOutputStream、ObjectOutputStream
字符输入流Reader
FileReader、BufferedReader、OutputStreamWriter
字符输出流Writer
FileWriter、BufferedWriter、InputStreamReader
按方向分类
-
输入流：InputStream、Reader
- 将硬盘中的数据读取到内存中
-
输出流：OutputStream、Writer
- 将内存中的数据写入到硬盘中
按类型分
- 字节流：InputStream、OutputStream
- 读写非文本类型文件。如图片、音视频、其他文件等。
- 字符流：Reader、Writer
- 读写纯文本类型文件。如txt、md等
如要将硬盘中某个txt文件中的内容读取到程序中，使用Reader
如要将硬盘中的某个图片读取到程序中，使用InputStream
如要将程序中的文本写入到硬盘中为txt类型文件时，使用Writer
如要将程序中的数据写入到硬盘中为非文本文件时，使用OutputStream
流的四个父类的特点
- 这四个父类都是在java.io包下，都是抽象类，不能直接创建其对象，使用其子类创建对象
- 这四个父类中都定义了close()方法，用于关闭流对象，释放资源
- 输入流(InputStream和Reader)都有read()方法读取数据到内存中，输出流都有write()方法写入数据到硬盘中
- 输出流(OutputStream和Writer)都有flush()方法，用于将流中的数据冲刷到硬盘中
- 在使用输出流对象时，一定要调用flush()或close()方法后，才能真正将数据写入到硬盘中
- 所有的流中，以Stream结尾，都是字节流，数据以字节传输；以Reader或Writer结尾的，都是字符流，数据以字符传输
- 读取硬盘中的数据，使用输入流，读取的文件必须存在；将数据写入到硬盘中，使用输出流，文件可以不存在，但父目录必须存在。
- 读入或写入文本时，使用字符流；读取或写入非文本时，使用字节流
FileInputStream文件字节输入流(掌握)
按字节读取硬盘中的文件。
构造方法
| 常用构造方法 | 说明 |
|---|---|
| FileInputStream(String pathName) | 根据文件名创建流对象 |
| FileInputStream(File file) | 根据文件对象创建流对象 |
常用方法
| 常用方法 | 说明 |
|---|---|
| read() | 读取一个字节，返回读取到的字节 |
| read(byte[] bytes) | 按字节数组读取，返回读取到的字节数量，读取到的内容保存在字节数组中 |
| close() | 关闭流对象 |
FileOutputStream文件字节输出流(掌握)
按字节将内存中的数据写入到硬盘中。
构造方法
| 常用构造方法 | 说明 |
|---|---|
| FileOutputStream(String pathname) | 根据文件名创建输出流对象，写入时覆盖原内容 |
| FileOutputStream(String pathname,boolean append) | 根据文件名创建输出流对象，第二个参数为true，写入时追加在原内容之后 |
| FileOutputStream(File file) | 根据文件对象创建输出流对象，写入时覆盖原内容 |
| FileOutputStream(File file,boolean append) | 根据文件对象创建输出流对象，第二个参数为true，写入时追加在原内容之后 |
常用方法
| 常用方法 | 作用 |
|---|---|
| write(int i) | 写入一个指定字节 |
| write(byte[] bytes) | 写入一个字节数组 |
| write(byte[] bytes,int off,int len) | 写入字节数组中从off开始的len个字节 |
| flush() | 将流中的数据冲刷到硬盘中 |
| close() | 关闭流对象 |
使用FileInputStream和FileOutputStream读写时的注意事项
-
在通过FileInputStream对象使用read(byte[] bytes)方法时，每次读取指定数组的字节，将读取到的字节保存在字节数组中，该方法返回读取到的字节数量。如果最后一次读取的字节数不足字节数组的大小时，只会将读取到内容覆盖数组中最前的几个元素。所以会导致读取到的内容多于实际内容。
-
在通过FileOutputStream对象使用write(byte[] bytes)方法时，会将字节数组中的所有内容写入到输出流中，在最后一次写入时，可能会写入多余的内容。所以在写入时，最好使用write(byte[] bytes,int off,int lef)方法，表示将字节数组中的内容，从off开始写入len个。
如有word.txt文件，其中保存aaabbbccc
FileInputStream fis = new FileInputStream("d:/word.txt"); FileOutputStream fos = new FileOutputStream("d:/copy.txt"); byte[] bytes = new byte[4]; //第一次读取4个字节，即aaab，count为4 int count=fis.read(bytes); //写入数组中的全部内容 fos.write(bytes); //第二次读取4个字节，即bbcc，count为4 count=fis.read(bytes); //写入数组中的全部内容 fos.write(bytes); //第三次读取1个字节c，覆盖数组中的第一个元素，即数组现在为cbcc,count为1 count=fis.read(bytes); //写入数组中的全部内容 fos.write(bytes);//最终会写入aaabbbcccbcc fos.write(bytes,0,count);//这样最后一次只会写入实际读取到的c fos.close(); fis.close();
使用FileInputStream和FileOutputStream实现单文件的复制
package com.hqyj.IOTest;
import java.io.*;
public class CopyFile {
public static void main(String[] args) throws IOException {
//定义原文件和目标文件
File source = new File("F:\\221001\\录屏\\FileInputStream和FileOutputStream.mp4");
File target = new File("F:\\221001\\copy.mp4");
//定义文件字节输入流，用于读取原文件
FileInputStream fis = new FileInputStream(source);
//定义文件字节输出流，用于写入文件
FileOutputStream fos = new FileOutputStream(target);
/*
//调用无参的read()方法，表示读取一个字节，返回读取到的字节
int read = fis.read();
//如果能读取到内容
while (read > -1) {
//将读取到的内容写入到文件中
fos.write(read);
//继续读取
read = fis.read();
}
*/
//定义一个字节数组，大小为8MB
byte[] bytes = new byte[1024 * 1024 * 8];
//按字节数组读取，返回读取到的字节数量
int count = fis.read(bytes);
//循环读取写入
while (count > -1) {
//将读取的字节数组写入到文件中
// fos.write(bytes);//如果调用该方法，最后一次会多写入上一次残留的数据
fos.write(bytes,0,count);//如果调用该方法，实际读取到了多少字节就写入多少
count = fis.read(bytes);
}
fis.close();
fos.close();
if (target.exists()) {
System.out.println("复制成功");
}
}
}
文件夹的复制
package com.hqyj.IOTest;
import java.io.*;
public class CopyDirectory {
public static void main(String[] args) {
/*File source = new File("F:\\221001\\录屏\\流的基本概念.mp4");
File target = new File("F:\\221001\\copy.mp4");
copyFile(source, target);*/
File source = new File("F:\\221001\\笔记");
File target = new File("F:\\221001\\笔记副本");
/*
* source F:\221001\笔记
* target F:\221001\笔记副本
* 1.调用copyDir方法，判断发现source是一个文件夹，创建目标文件夹target:“F:\221001\笔记副本”
* 2.遍历source,如其中有xxx.md文件，即child
* 此时的source是F:\221001\笔记\xxx.md,即child
* 此时的target是F:\221001\笔记副本\xxx.md,用File(File parent,String child)构造方法表示这个目标文件
* 所以创建File newTarget = new File(target,child.getName())
*
* */
copyDir(source, target);
}
/*
* 定义复制文件夹的方法
* */
public static void copyDir(File source, File target) {
//如果是文件，调用单文件复制的方法
if (source.isFile()) {
copyFile(source, target);
} else {//如果是文件夹
//创建要复制的目标文件夹
target.mkdir();
//展开原文件夹
for (File child : source.listFiles()) {
//定义复制后的新目标文件
//如source为F:\221001\笔记\day1.md时，递归调用的target为F:\221001\笔记副本\day1.md
File newTarget = new File(target, child.getName());//这里使用File(File parent,String child)构造方法创建target对象
//递归调用的原文件依然是当前遍历出来的子文件，目标文件就是最终复制的F:\221001\笔记副本\day1.md
copyDir(child, newTarget);
}
}
}
/*
* 定义单文件复制的方法
* */
public static void copyFile(File source, File target) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建用于输入输出的流对象
fis = new FileInputStream(source);
fos = new FileOutputStream(target);
//定义字节数组
byte[] bytes = new byte[1024 * 1024 * 8];
//按数组读取
int count = fis.read(bytes);
while (count != -1) {
fos.write(bytes, 0, count);
count = fis.read(bytes);
}
} catch (FileNotFoundException e) {
System.out.println("文件不存在" + e);
} catch (IOException e) {
System.out.println("读写异常" + e);
} finally {
try {
if (fis != null) {
fis.close();
}
if (fos != null) {
fos.close();
}
} catch (IOException e) {
System.out.println("关闭流对象异常" + e);
}
}
}
}
断点调试执行细节
FileReader文件字符输入流
按字符读取文件。
构造方法
| 常用构造方法 | 说明 |
|---|---|
| FileReader(String fileName) | 根据文件名创建文件字符输入流对象 |
| FileReader(File file) | 根据文件对象创建文件字符输入流对象 |
常用方法
| 常用方法 | 作用 |
|---|---|
| ready() | 判断是否还有下一个字符 |
| read() | 读取下一个字符，返回读取到的字符 |
| read(char[] chars) | 按字符数组读取，返回读取到的字符数量，读取到的字符保存在字符数组中 |
| close() | 关闭流对象 |
FileWriter文件字符输出流
按字符写入文件。
构造方法
| 常用构造方法 | 作用 |
|---|---|
| FileWriter(String fileName) | 按文件名创建字符输出流对象，覆盖写入 |
| FileWriter(String fileName,boolean append) | 按文件名创建字符输出流对象，如果append为true，表示追加写入 |
| FileWriter(File file) | 按文件对象创建字符输出流对象，覆盖写入 |
| FileWriter(File file,boolean append) | 按文件对象创建字符输出流对象，如果append为true，表示追加写入 |
常用方法
| 常用方法 | 作用 |
|---|---|
| write(String str) | 按字符串写入 |
| flush() | 将流中的数据冲刷到硬盘中的文件，必须调用该方法或close方法后，才能真正写入 |
| close() | 关闭流对象 |
BufferedReader缓冲字符输入流(掌握)
自带缓冲区(字符数组)的字符输入流。默认字符数组大小为8192，每次最多读取8192个字符。
在读取纯文本文件(txt或md)时，首选该类。
构造方法
| 常用构造方法 | 作用 |
|---|---|
| BufferedReader(Reader in) | 创建一个带有缓冲区(大小为8192的char数组)的字符输入流对象，参数为Reader类型对象，Reader是抽象类，所以实际参数为Reader的子类，如FileReader，在FileReader对象中定义要读取的文件 |
| BufferedReader(Reader in，int size) | 创建一个指定缓冲区(字符数组)大小的字符输入流对象 |
常用方法
| 常用方法 | 作用 |
|---|---|
| ready() | 判断是否还有字符 |
| readLine() | 读取整行字符 |
| close() | 关闭流对象 |
读取文本练习
package com.hqyj.ReaderAndWriter;
import java.io.*;
public class Test2 {
public static void main(String[] args) throws IOException {
/*
File file = new File("F:\\221001\\笔记\\Java基础回顾.md");
//FileReader(File file)
Reader fr = new FileReader(file);
//BufferedReader(Reader in)
BufferedReader br = new BufferedReader(fr);
*/
//创建带有缓冲区的字符输入流对象
BufferedReader br = new BufferedReader(new FileReader("F:\\221001\\笔记\\Java基础回顾.md"));
//循环判断是否还有字符
while (br.ready()) {
//读取整行
System.out.println(br.readLine());
}
//关闭最大的流对象即可
br.close();
}
}
BufferedWriter缓冲字符输出流(掌握)
自带缓冲区(字符数组)的字符输出流
构造方法
| 常用构造方法 | 说明 |
|---|---|
| BufferedWriter(Writer writer) | 创建一个自带缓冲区的字符输出流对象，参数为一个Writer对象，Writer是一个抽象类，实际参数为Writer的子类，如FileWriter，在FileWriter中定义要将输入写入的目标文件 |
| BufferedWriter(Writer writer，int size) | 创建一个指定缓冲区大小的字符输出流对象 |
常用方法
| 常用方法 | 作用 |
|---|---|
| write(String str) | 写入字符串 |
| newLine() | 换行 |
| flush() | 冲刷流中的数据到硬盘 |
| close() | 关闭流对象 |
写入文本练习
package com.hqyj.ReaderAndWriter;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.logging.SimpleFormatter;
public class Test3 {
public static void main(String[] args) throws IOException {
File file = new File("221001.txt");
//创建缓冲字符输入流对象，读取文本
BufferedReader br = new BufferedReader(new FileReader(file));
//创建集合，保存读取到的姓名
ArrayList<String> list = new ArrayList<>();
//循环读取文件中的所有字符
while (br.ready()) {
String name = br.readLine();
list.add(name);
}
//关闭
br.close();
//打乱集合中的元素
Collections.shuffle(list);
//创建日期字符串
String today = new SimpleDateFormat("yyyy.MM.dd").format(new Date());
//创建缓冲字符输出流，用于写文本，文件名为"日期+作业情况.txt",如果每次都是新建，这样写
// BufferedWriter bw = new BufferedWriter(new FileWriter(today + "作业情况.txt"));
//如果要追加，在new FileWriter("文件名",true)设置
BufferedWriter bw = new BufferedWriter(new FileWriter(today + "作业情况.txt",true));
//写入字符串
bw.write("姓名\t\t是否完成");
//换行
bw.newLine();
Scanner sc = new Scanner(System.in);
//随机3个人
for (int i = 0; i < 3; i++) {
String name = list.get(i);
System.out.println(name + "完成情况:");
String str = sc.next();
//写入读取到的内容
bw.write(name + "\t\t" + str);
//换行
bw.newLine();
}
bw.close();
}
}
ObjectOutputStream对象字节输出流(序列化)(掌握)
序列化：将对象转换为文件的过程
被序列化的对象，必须要实现Serializable接口。
这个接口是一个特殊的接口，没有定义任何方法，只是给该类加上标记，表示该类可以被序列化
构造方法
| 构造方法 | 说明 |
|---|---|
| ObjectOutputStream(OutputStream os) | 创建一个对象字节输出流对象，参数为一个字节输出流对象，由于OutputStream是抽象类，所以使用其子类，如FileOutputStream对象，在其中定义要写入的文件 |
常用方法
| 常用方法 | 作用 |
|---|---|
| writeObject(Object obj) | 将一个对象写入到本地文件中 |
| close() | 关闭流对象 |
ObjectInputStream对象字节输入流(反序列化)(掌握)
反序列化：将文件转换为对象的过程
构造方法
| 常用构造方法 | 说明 |
|---|---|
| ObjectInputStream(InputStream is) | 创建一个对象字节输入流对象，参数为一个字节输入流对象，由于InputStream是抽象类，所以使用其子类，如FileInputStream对象，在其中定义要读取的文件 |
常用方法
| 常用方法 | 作用 |
|---|---|
| readObject() | 读取序列化后的文件，返回类型为Object |
| close() | 关闭流对象 |
序列化和反序列化案例
Person类，实现Serializable接口
package com.hqyj.ObjectStream;
import java.io.Serializable;
/*
* 如果希望该类的对象能序列化，写入对象到本地，必须要实现Serializable接口
* Serializable接口中没有任何方法，是一个标记接口，表示该类的对象可以被序列化
* */
public class Person implements Serializable {
private String name;
private int age;
private String sex;
//省略getter/setter和toString()
}
Main类
package com.hqyj.ObjectStream;
import java.io.*;
import java.util.ArrayList;
public class Test1 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Person p1 = new Person("王海", 22, "男");
Person p2 = new Person("赵敏", 24, "女");
Person p3 = new Person("刘涛", 21, "女");
ArrayList<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
//创建OutStream的实现类，设置写入的文件路径
OutputStream os = new FileOutputStream("F:\\221001\\person.p");
//创建对象输出字节流，参数为OutStream类型
ObjectOutputStream oos = new ObjectOutputStream(os);
//调用writeObject(Object obj)方法，将对象写入到硬盘中(序列化)
oos.writeObject(list);
oos.close();
//创建对象输入字节流，将上一步保存的文件进行反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\221001\\person.p"));
//使用readObject()方法，将写入的文件进行读取(反序列化)
ArrayList<Person> pList = (ArrayList<Person>) ois.readObject();
for (Person person : pList) {
System.out.println(person);
}
ois.close();
}
}
转换流
实际属于字符流，作用为将一个字节流对象转换为字符流对象
OutputStreamWriter
将字节输出流转换为字符输出流
InputStreamReader
将字节输入流转换为字符输入流
转换流的使用
如果只提供了一个字节流，但要向其中写入或读取字符时，就可以使用转换流将字节流转换为字符流。
使用字符流读写字符时比字节流更方便。
//假如只提供一个字节输出流对象
FileOutputStream fos = new FileOutputStream("文件路径");
//fos.write(97);//这时如果写入数据，只能按字节写入，不方便
//使用转换流，将字节流对象fos转换为字符流对象
Writer writer = OutputStreamWriter(fos);
//将字符流对象writer包装成缓冲字符流对象
BufferedWriter bw = new BufferedWriter(writer);
bw.write("hello你好");
bw.newLine();
bw.close();
//只提供字节输入流对象
FileInputStream fis = new FileInputStream("221001.txt");
// fis.read()每次只能读取一个字节
//将字节流转换为字符流
Reader reader = new InputStreamReader(fis);
//创建缓冲字符流，将字符流包装为缓冲流
BufferedReader br = new BufferedReader(reader);
//整行读取
while (br.ready()) {
System.out.println(br.readLine());
}
br.close();
网络编程
InetAddress类
表示IP对象的一个类
public static void main(String[] args) throws UnknownHostException {
//获取本机的ip对象
// InetAddress ip = InetAddress.getLocalHost();
//获取域名
// System.out.println(ip.getHostName());
//获取真实ip地址
// System.out.println(ip.getHostAddress());
//getByName(域名) 得到域名对应的ip对象
//localhost域名表示本机，对应的ip地址为127.0.0.1
InetAddress ip = InetAddress.getByName("localhost");
//获取域名
System.out.println(ip.getHostName());
//获取ip地址
System.out.println(ip.getHostAddress());
}
Socket类和ServerSocket类
都属于Socket(套接字)对象，表示网络中的某个端点
- Socket指普通端
- ServerSocket指服务器端
使用套接字对象实现两个端点(Socket和ServerSocket)之间发送文件
服务器端
package com.hqyj.uploadTest;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
/*
* 使用套接字对象，实现客户端向服务端发送文件
*
* 定义服务端套接字对象
* */
public class Server {
public static void main(String[] args) throws IOException {
//以本机创建服务端套接字对象
ServerSocket server = new ServerSocket(8899, 100, InetAddress.getLocalHost());
//等待客户端连接，返回连接的客户端套接字对象
Socket client = server.accept();
//定义要将读取到的数据写入到本地的文件字节输出流对象
FileOutputStream fos = new FileOutputStream("上传文件.md");
//获取客户端与服务端的输入流对象，读取发送的数据
InputStream is = client.getInputStream();
//定义读取的字节数组
byte[] bytes = new byte[1024 * 1024 * 8];
int count = is.read(bytes);
while (count != -1) {
//将读取到的数据写入到本地
fos.write(bytes, 0, count);
count = is.read(bytes);
}
fos.close();
is.close();
}
}
客户端
package com.hqyj.uploadTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
/*
* 定义客户端套接字对象
* */
public class Client {
public static void main(String[] args) throws IOException {
//创建客户端套接字对象，连接指定的服务端套接字对象
Socket client = new Socket("192.168.31.39", 8899);
//获取客户端与服务端的输出流对象
OutputStream os = client.getOutputStream();
//成功连接后，将某个文件发送给服务端
//定义要发送的文件对象
File file = new File("F:\\221001\\笔记\\面向对象部分回顾.md");
//读取要发送的文件
FileInputStream fis = new FileInputStream(file);
//定义字节数组
byte[] bytes = new byte[1024 * 1024 * 8];
//循环读取要发送的文件
int count = fis.read(bytes);
while (count != -1) {
//将读取到的数据写入到客户端套接字与服务端套接字的通道中
os.write(bytes,0,count);
count = fis.read(bytes);
}
fis.close();
os.close();
}
}
进程和线程
进程Process
进程就是操作系统中执行的程序。一个程序就是一个执行的进程实体。
每个运行中的进程，都有属于它独立的内存空间，各个进程互不影响。
线程Thread
线程是一个进程中的执行单元，一个进程中可以有多个线程。
多个线程，可以访问同一个进程中的资源。
每个线程都有一个独立的栈空间，这些线程所在的栈空间位于同一个进程空间中。
多线程
如果一个进程中，同时在执行着多个线程，就称为多线程。
多线程可以提高程序执行效率。如多个窗口卖票，可以加快卖票的效率。
其实每个执行的Java程序，都是多线程执行，main方法称为主线程，还有gc线程(守护线程)在同时运行。
如有一个工厂，工厂中有很多车间，每个车间有很多流水线。
工厂就是内存，车间就是各个进程，每个流水线都是一个进程中的一个线程。
并行和并发
并行
各个进程同时执行，称为并行。
并发
多个线程同时执行，称为并发。
同步和异步
同步
所有的任务排队执行，称为同步执行。
异步
在执行任务A的同时，执行任务B，称为异步执行。
Java中的线程Thread类
Java中，线程以对象的形式存在。
Thread类表示线程类
获取线程对象
-
获取当前正在运行的线程对象
Thread ct = Thread.cuurentThread(); -
创建一个线程对象
构造方法
常用构造方法 说明 Thread() 创建一个默认的线程对象 Thread(String name) 创建一个指定名称的线程对象 Thread(Runnable target) 将一个Runnable对象包装为线程对象 Thread(Runnable target,String name) 将一个Runnable对象包装为线程对象同时设置线程名
线程常用方法
| 方法 | 作用 |
|---|---|
| getId() | 获取线程id |
| getName() | 获取线程名，默认Thread-n |
| getPriority() | 获取线程优先级，默认为5 |
| getState() | 获取线程状态 |
| setName(String str) | 设置线程名 |
| setPriority(int priority) | 设置线程优先级，范围在1-10，值越大越优先执行 |
| isDaemon() | 判断线程是否为守护线程 |
| setDaemon(boolean f) | 参数为true表示设置线程为守护线程 |
| start() | 让线程进入就绪状态 |
| run() | 线程获得执行权时执行的方法(线程要做的事情) |
| Thread.sleep(long m) | 设置当前线程休眠m毫秒 |
| Thread.currentThread() | 获取当前执行的线程对象 |
| Thread.yield() | 线程让步 |
实现多线程
方式一：继承Thread类
- 1.创建一个类，继承Thread类
- 2.重写Thread类中的run()方法
- 3.创建自定义的线程子类对象后，调用start()方法
自定义Thread线程的子类
package com.hqyj.ThreadTest;
/*
* 实现多线程步骤
* 1.成为Thread的子类
* 2.重写run()方法
* 3.创建当前类对象后，调用start()方法
* */
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//让该线程输出0-99
System.out.println(getName() + ":" + i);
}
}
public MyThread(String name) {
super(name);
}
public MyThread() {
}
}
main类
package com.hqyj.ThreadTest;
public class Test2 {
public static void main(String[] args) {
//创建无参数的自定义线程对象
MyThread t1 = new MyThread();
t1.setName("线程A");
//创建自定义线程对象,参数为线程名
MyThread t2 = new MyThread("线程B");
//让两个线程自动执行，必须调用start()
t1.start();
t2.start();
}
}
方式二：实现Runnable接口(建议使用)
由于Java中是单继承，如果某个类已经使用了extends关键字去继承了另一个类，这时就不能再通过extends继承Thread实现多线程。
就需要实现Runnable接口的方式实现多线程。
- 1.自定义一个类，实现Runnable接口
- 2.重写run()方法，将多线程要执行的内容写在该方法中
- 3.创建Runnable接口的实现类对象
- 4.使用构造方法Thread(Runnable target)或Thread(Runnable target，String name)将上一步创建的Runnable实现类对象包装为Thread对象
自定义Runnable接口的实现类
package com.hqyj.ThreadTest;
/*
* 实现多线程步骤
* 1.成为Runnable的实现类
* 2.重写run()方法
* 3.创建该类对象
* 4.将其包装为Thread对象
* */
public class MyThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//让该线程输出0-99
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
main类
package com.hqyj.ThreadTest;
public class Test2 {
public static void main(String[] args) {
//创建Runnable接口的实现类
Runnable target = new MyThread2();
//由于启动多线程必须要通过Thread的start()方法，所以一定要创建Thread对象
Thread mt = new Thread(target,"线程A");//这里使用Thread(Runnable target)构造方法创建Thread对象
//让线程就绪
mt.start();
//创建另一个线程对象，让线程就绪
new Thread(new MyThread2(),"线程B").start();
}
}
方式三：使用匿名内部类
如果不想创建一个Runnable接口的实现类，就可以使用匿名内部类充当Runnable接口的实现类
package com.hqyj.ThreadTest;
/*
* 实现多线程的方式三：
* 使用匿名内部类
* */
public class Test3 {
public static void main(String[] args) {
//使用Thread(Runnable target ,String name)构造方法创建线程对象
//此时new Runnable() { @Override public void run() {}}就是一个匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}, "自定义线程").start();
//如果main方法当做一个线程时，需要先启动其他线程后，在执行main方法中的内容，否则依然是按顺序执行
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
线程的生命周期
线程的初始化到终止的整个过程，称为线程的生命周期。
新生状态
当线程对象被创建后，就进入了新生状态。
就绪状态
当某个线程对象调用了start()方法后，就进入了就绪状态。
在这个状态下，线程对象不会做任何事情，只在等他CPU调度。
运行状态
当某个线程对象得到CPU时间片(CPU执行这个线程的机会所给的时间)，则进入运行状态，开始执行run()方法。
不会等待run()方法执行完毕，只会在指定的时间内尽可能地执行run()方法。只要调用玩run()方法后，就会再进入就绪状态。
阻塞状态
如果某个线程遇到了sleep()方法或wait()方法时，就会进入阻塞状态。
sleep()方法会在指定时间后，让线程重新就绪。
wait()方法只有在被调用notify()或notifyAll()方法唤醒后才能重新就绪。
终止状态
当某个线程的run()方法中的所有内容都执行完，就会进入终止状态，意味着该线程的使命已经完成。
守护线程
如果将一个线程设置setDeamon(true)，表示该线程为守护线程。
守护线程会随着其他非守护线程终止而终止。
package com.hqyj.DaemonTest;
/*
* Test类是一个自定义线程类，死循环输出
* */
public class Test implements Runnable {
public static void main(String[] args) {
Thread thread = new Thread(new Test());
//将自定义线程类设置为守护线程
thread.setDaemon(true);
thread.start();
//main线程终止，守护线程也会终止
for (int i = 0; i < 100; i++) {
System.out.println("main方法中的循环执行中");
}
}
@Override
public void run() {
while (true) {
System.out.println("守护线程执行中。。。");
}
}
}
多线程访问同一个资源
可能出现的问题
如银行存款100，同一时刻在手机和ATM一起取出，如果用多线程模拟，可能会出现两个线程都取出100的情况。要避免这种情况发生。
本应该大于售出后再减，再打印剩余，由于线程A在打印"售出一张"后，还没来得及执行后续内容，其他线程就开始执行了。
出现问题的原因
由于线程调用start()方法后，就进入就绪状态。如果获得了CPU时间片，就开始调用run()方法，调用run()方法后，就会再次进入就绪状态，不会等待run()方法执行完毕，所以在线程A执行run()方法的时候，线程B也开始执行了，这样就会出现数据共享的问题。
因为现在所有的线程都是异步(同时)执行。
如何解决
让线程同步(排队)执行即可。这样一来，某个线程执行run()方法的时候，让其他线程等待run()方法的内容执行完毕。
synchronized关键字
这个关键字可以修饰方法或代码块
修饰方法
写在方法的返回值之前，这时该方法就称为同步方法。
public synchronized void fun(){
//会排队执行的代码
}
修饰代码块
写在一个独立的{}前，这时该段内容称为同步代码块。
synchronized(要同步的对象或this){
//会排队执行的代码
}
原理
每个对象默认都有一把"锁"，当某个线程运行到被synchronized修饰的方法时，该对象就会拥有这把锁，在拥有锁的过程中，其他线程不能同时访问该方法，只有等待其结束后，才会释放这把锁。
使用synchronized修饰后的锁称为"悲观锁"。
方法被synchronized修饰后，称为同步方法，就会让原本多线程变成了单线程(异步变为同步)。
多线程相关面试题
-
实现多线程的方式
- 继承Thread类
- 实现Runnable接口后，包装为Thread对象
- 匿名内部类
-
为什么说StringBuilder或ArrayList、HashMap是非线程安全的
package com.hqyj.ThreadSafe; public class Test { public static void main(String[] args) throws InterruptedException { // StringBuilder sb = new StringBuilder(); StringBuffer sb = new StringBuffer(); //循环10次创建10个线程对象 for (int i = 0; i < 10; i++) { //创建线程对象 new Thread(new Runnable() { @Override public void run() { //每个线程都向StringBuilder对象中添加100次字符串 try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } for (int j = 0; j < 10; j++) { sb.append("hello"); } } }).start(); } Thread.sleep(5000); //如果正常，应该长度为10线程*10次添加*每次5个字母 长度为500 System.out.println(sb.length()); //如果用StringBuilder，最终的长度可能不为500 //如果用StringBuffer，最终的长度一定为500 //所有StringBuffer是线程安全的，适用于多线程 //所有StringBuilder是非线程安全的，适用于单线程 } } -
什么叫死锁？怎么产生？如何解决？
如果有两个人吃西餐，必须有刀和叉，此时只有一副刀叉。
如果A拿到了刀，B拿到了叉，互相都在等待另一个工具，但都不释放自己拥有的，这时就会造成僵持的局面，这个局面就称为死锁，既不结束，也不继续。
模拟死锁出现的情况
定义两个线程类，线程A先获取资源A后，在获取资源B；线程B先获取资源B后，再获取资源A。
如果对资源A和资源B使用了synchronized进行同步，就会在线程A获取资源A的时候，线程B无法获取资源A，相反线程B在获取资源B的时候，线程A无法获取资源B，所以两个线程都不会得到另一个资源。
PersonA线程
package com.hqyj.deadlock;
public class PersonA implements Runnable {
//定义两个共享的成员变量，刀、叉
private Object knife;
private Object fork;
public PersonA(Object knife, Object fork) {
this.knife = knife;
this.fork = fork;
}
/*
* 该线程执行run方法时，先获取knife对象，等待3s后获取fork对象
*
* */
@Override
public void run() {
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,3s后获取fork");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,可以吃饭了");
}
}
}
}
PersonB线程
package com.hqyj.deadlock;
public class PersonB implements Runnable {
//定义两个共享的成员变量，刀、叉
private Object knife;
private Object fork;
public PersonB(Object knife, Object fork) {
this.knife = knife;
this.fork = fork;
}
/*
* 该线程执行run方法时，先获取fork对象，等待3s后获取对象knife
*
* */
@Override
public void run() {
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,3s后获取knife");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,可以吃饭了");
}
}
}
}
死锁的解决方式
方式一
让两个线程获取资源的顺序保持一致。
如两个线程都先获取knife，再获取fork
@Override
public void run() {
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,3s后获取fork");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,可以吃饭了");
}
}
}
方式二
让两个线程在获取资源A和B之前，再获取第三个资源，对第三个资源使用synchronized进行同步，这样某个线程在获取第三个资源后，将后续内容执行完毕，其他线程才能开始执行。
如在获取knife和fork之前，先获取paper对象
@Override
public void run() {
//先获取paper，再进行后续操作
synchronized (paper) {
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,3s后获取fork");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,可以吃饭了");
}
}
}
}
println(Thread.currentThread().getName() + "获取了fork,可以吃饭了");
}
}
}
}
PersonB线程
package com.hqyj.deadlock;
public class PersonB implements Runnable {
//定义两个共享的成员变量，刀、叉
private Object knife;
private Object fork;
public PersonB(Object knife, Object fork) {
this.knife = knife;
this.fork = fork;
}
/*
* 该线程执行run方法时，先获取fork对象，等待3s后获取对象knife
*
* */
@Override
public void run() {
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,3s后获取knife");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,可以吃饭了");
}
}
}
}
死锁的解决方式
方式一
让两个线程获取资源的顺序保持一致。
如两个线程都先获取knife，再获取fork
@Override
public void run() {
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,3s后获取fork");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,可以吃饭了");
}
}
}
方式二
让两个线程在获取资源A和B之前，再获取第三个资源，对第三个资源使用synchronized进行同步，这样某个线程在获取第三个资源后，将后续内容执行完毕，其他线程才能开始执行。
如在获取knife和fork之前，先获取paper对象
@Override
public void run() {
//先获取paper，再进行后续操作
synchronized (paper) {
synchronized (knife) {
System.out.println(Thread.currentThread().getName() + "获取了knife,3s后获取fork");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (fork) {
System.out.println(Thread.currentThread().getName() + "获取了fork,可以吃饭了");
}
}
}
}
个人总结
首先在本周学习的知识很多，但是比起难度来说，可能前面几周的比较有难度，虽然本周学习到的知识难，但是多呀，并且有绝大多数的知识点，并不是什么时候都适用的，必须在一定条件下才能用得到，再加上我们的码龄并不大，所有我觉得我们还需要跟多的时间去适用这些方法的使用，
其次老师也很我们说过这么多方法我们要是想靠着死记硬背估计是挺困难的，只是需要在我们需要使用这个方法的时候能够让我们想起来有一些方法可以直接解决我当时候需要解决的问题，不需要我们能够具体记得是哪一个方法，只需要我们知道有这种方法，比如昨天的作业 需要我们把读取到的字符串进行拆分，但是我当时并没有想到substring(int being,int end)这个方法，但是我只想到了用字符数组来存，然后就可以得到我想要的长度了，但是在做作业的过程中，我发现虽然我的这种办法也是可行的，但是太过于麻烦，过于复杂，直到我想起来了这个方法可以用于对字符串的截取，我才恍然大悟，我觉得在java的高级阶段，并不是学到很多厉害的代码技术，而是做到我最开始就说的，高级，什么叫高级，就是能够把一个事情简单化，我觉得本周学习到的大部分知识点都是来告诉我们如何把问题简单化，并且高效的来完成，虽然本周需要记的方法有很多，但是我觉得只要自己去多看几遍，就算自己不能够准确的把方法给写出来，但是起码知道有这样一种方法能够实现我们的想法，现在科技怎么发达，只要你能想起来，就能够在网上找到你所想到的那种方法！希望在接下来的学习里能够把老师所说的知识点给尽量吃透，吃完！
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
