华清远见重庆中心Java高级知识总结

最新推荐文章于 2024-06-20 20:20:21 发布

qq_53837616

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量87

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_53837616/article/details/128177451

版权

字符串String

String是一个类，属于数据类型中的引用类型。
Java中一切使用""引起来的内容，都是这个类的实例，称为字符串对象。
字符串在定义后，值不可改变，是一个常量，实际是一个字符数组。
如果频繁地将一个String类型变量的值进行更改时，会创建很多字符串对象。效率

低，浪费内存空间。所以在频繁更改字符串时，不要使用String类变量。如果要频繁更改字符串，使用StringBuilder类或StringBuffer类

字符串对象的创建

使用""赋值创建

String str="abc"

通过构造方法创建

使用构造方法String(String str)创建

String str1=new String("ab")

总结

在使用字符串时，如果要比较其值是否相同，不要使用==判断，因为==判断的是内存地址
在比较字符串是否相同时，要使用String类重写的equals方法进行判断

字符串String类中的常用方法

方法名	返回值	作用
length()	int	得到字符串的长度
toLowerCase()	String	转换为小写
toUpperCase()	String	转换为大写
trim	String	去除字符串首尾的所有空格
isEmpty()	boolean	判断字符串是否为空白字符串""

getBytes()	byte[]	将字符串转换为字节数组
toCharArray()	char[]	将字符串转换为字符数组
equalsIgnoreCase(String str)	boolen	忽略大小写判断两个字符串是否相同
equals(String str)	boolen	判断两个字符串是否相同
charAt(int index)	char	得到字符串指定索引上的字符
indexOf(String str)	int	得到字符串中某个子字符串第一次出现的索引，如果不存在，返回-1

lastIndexOf(String str)	int	得到字符串中某个子字符串最后一次出现的索引，如果不存在，返回-1
contains(字符序列)	boolen	判断某个子字符串是否在原字符串中出现
concat(String str)	String	将参数字符串拼接到原字符串末尾
startsWith(String str)	boolean	判断是否以指定字符串开头
substring(int begin)	String	从指定索引开始截取字符串至末尾
substring(int being,intend)	String	截取[begin,end)区间内的字符串

split(String regex)	String[]	按执行字符串或正则表达式切分原字符串。如果指定内容不再末尾，n个指定字符能得到n+1个子串;如果指定内容在末尾，n个指定字符能得到n个子串(不包含末尾的无效字符)
replace(char
oldChar,char newChar)	String	将原字符串中的所有指定字符替换为新字符
String.valueOf(参数)	String	将任意参数转换为字符串。通常用于原始类型转换为字符串。

可变字符串

String字符串对象是一个常量，在定义后，值不可改变。

如果使用String类的对象，对其频繁更新时，就会不停地创建新的对象，不停引用给同一个变量。

StringBuilder类

用于表示可变字符串的一个类，是非线程安全的，建议在单线程环境下使用

StringBuffer类

用于表示可变字符串的一个类，是线程安全的，建议在多线程环境下使用

StringBuilder和StringBuffer中的方法都一致，只不过StringBuffer中的方法使用了synchoronized关键字修饰，表示是一个同步方法，在多线程环境下不会出现问题。

构造方法

StringBuilder()和StringBuilder(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判断

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类的对象。

方法调用传值问题总结

参数只有是引用类型(类、数组、接口),并且方法中在直接操作该参数时，才会对实际参数造成影响。

例子：

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包下

主要构造方法：Data data=new Date();创建当前瞬间对应的日期对象

常用方法：

getTime()	得到对应Date对象表示的毫秒数
setTime(long l)	设置Date对象的毫秒数
after(Date when)	判断调用日期对象是否在when之后
before(Date when)	判断调用日期对象是否在when之前

SimpleDateFormat类

用于格式化日期的类。

构造方法：

SimpleDateFormat(String pattern);创建一个指定日期模板的格式化日期对象

常用方法

format(Date date)	将Date对象按日期模板转换为字符串
parse(String str)	将满足日期模板的字符串转换为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);
}
}

包装类

包装类就是原始类型对应的类类型。包装类通常用于字符串与原始类型之间的转换。

在web应用中，从浏览器页面中获取到后台的数据，全部都是String类型，所以一定要使用转换为原始类型的方法。

特点

八个原始类型中，除了int和char，其余类型的包装类，都是将首字母改为大写。int对应

Integer,char对应Character

包装类都是被final修饰的，不能被继承
除了Character类，其余包装类都有两个构造方法：参数为原始类型或String的构造方法。
Character的构造方法只有一个，参数为char类型。这些构造方法用于将原始类型或字符串转换为包装类对象
除了Character类，其余类都有静态方法parse原始类型(String str)，用于将字符串转换为相应的原始类型
数值型的包装类的parseXXX()方法，如果参数不是对应的数字，转换时就会抛出

NumberFormat异常。如"123abc"，或"123.4"，在使用Integer.parseInt()时都会抛出异常

Boolean类型中的parseBoolean()方法，参数如果是"true"这四个字母，不区分大小写，都能

转换为真正boolean类型的true，只要不是"true"这个单词，转换结果都为false

除了Boolean类，其余包装类都有MAX_VALUE和MIN_VALUE这两个静态属性，用于获取对应类型支持的最大最小值
所有包装类都重写了toString()方法，用于将包装类对象转换为String对象

字符串转换为原始类型

使用原始类型对应的包装类，调用parse原始类型(字符串)方法

ing num="123";
byte b = Byte.parseByte(num);//123
short s = Short.parseShort(num);//123
int i = Integer.parseInt(num);//123
long l = Long.parseLong(num);//123
float f = Float.parseFloat(num);//123.0
double d = Double.parseDouble(num);//123.0
boolean flag = Boolean.parseBoolean(num);//false

原始类型转换为字符串

使用+拼接一个空白字符串
```
int num = 123;
String str = num + "";
```

将原始类型转换为包装类后，调用toString()方法

int num = 123;
Integer integer = new Integer(num);
String str = integer.toString();

String.valueOf(原始类型数据)

int num = 123;
String str = String.valueOf(num);

装箱和拆箱

所有包装类都有一个静态方法valueOf(原始类型)，将某个原始类型的数据转换为相应的包装类对象。这个过程称为装箱boxing。
所有包装类都有一个原始类型Value()方法，用于将包装类对象转换为原始类型。这个过程称为拆箱unboxing。
自动装箱和拆箱。在jdk1.5之后，为了方便原始类型和包装类之间做转换，加入了自动装箱拆箱的概念，可以直接将原始类型和包装类对象之间互相赋值
自动装箱缓冲区
- 如果通过构造方法创建的包装类对象，会有不同的内存地址，使用==判断结果为false
- 自动装箱方式创建包装类对象，赋值范围在byte范围[-128,127]内，将这个值保存在缓冲区中，如果多个对象使用同一个数值，共享这个数据，使用同一个地址，使用==判断结果为true;如果不再byte范围内，就会创建新的包装类对象，会有不同的内存地址，使用==判断结果为false
- 引用类型对象比较值是否相同时，不要使用==，而是要使用重写的equals方法

异常

异常在程序中以对象的形式存在。当代码执行过程中出现异常，虚拟机会自动创建一个异常对象，如果没有对象该异常对象进行处理，就会导致程序中断，不再执行后续代码。

Error错误：

如果出现xxxxError，如StactOverFlowError，栈空间溢出，无法通过额外的代码解决，只能修改源码。

Exception异常：

运行时异常RuntimeException

如果一个异常类属于RuntimeExcption异常类的子类，称为运行时异常，可以通过编译，可以不用处理，运行时可能抛出异常对象。

NullPointerException	空指针异常	用空对象null调用属性或方法
ArrayIndexOutOfBoundsException	数组下标越界异常	使用数组时，下标超出范围
NumberFormatException	数字格式异常	使用包装类调用parse方法做转换时，无法将参数转换。如String str="123abc";int i=Integer.parseInt(str)
InputMismatchException	输入不匹配异常	使用Scanner接收控制台输入时，如果不满足接收的类型。如int i = sc.nextInt()实际输入a
ClassCastException	对象转型异常	Person p = (Person)Object obj;
ArithmeticException	算数运算异常	0当分母

处理异常

方式一：try-catch-finally语句

try{
//可能出现异常的代码
}catch(异常类 异常对象){
//如果出现异常对象，且与catch小括号中的异常类型匹配，就会执行这里的代码
}catch(异常类 异常对象){
//如果出现异常对象，且与catch小括号中的异常类型匹配，就会执行这里的代码
}finally{
//无论程序是否会抛出异常，都要执行的代码
}

执行流程：先执行try中的代码，当出现异常，与后续catch中的异常类型进行匹配，如果匹配到对应的类型或异常父类型，则执行大括号中的代码，最终一定执行finally中的内容

try-catch-finally使用时注意:

try、catch、finally都不能单独使用，try需要配合catch或finally或catch和finally一起使用
执行try中的内容时，当某行代码抛出异常，不再执行try中该行代码后续的内容
无论try中的代码是否会抛出异常，finally中的代码一定会执行
如果代码会抛出多个异常，可以使用多个catch进行捕获，需要将异常子类放在最前，异常父类放在最后
在try中定义的内容，无法在try之外的地方使用
try中如果有return，不影响finally的执行，finally优先于return执行

方式二：throws关键字

这种方式，可以让编译时异常通过编译。

在定义方法的时候，通过该关键字声明可能抛出的异常。

用法：方法的参数部分之后，添加"throws 异常类型1,异常类型2..."

public class Test{
public void fun() throws InterruptException{//这时该方法就会有一个声明：该方法可能
会抛出异常
//这句话直接写完后，会报错，因为sleep()方法可能会抛出InterruptException异常，属于
编译时异常，必须要处理
Thread.sleep(500);
}

集合

集合框架(集合家族)

Collection接口

List接口(有序可重复)

有序集合，元素可以重复，允许保存null，可以通过索引获取对应位置上的元素。

在该接口继承Collection接口的同时，又拓展了一些操作元素的方法，如添加到指定索引、根据索引删除、获取指定索引的元素、截取子集合的方法等。

ArrayList实现类(掌握)

采用数组实现的集合
可以通过索引访问元素，可以改变集合大小。如果要在其中插入或删除元素时，会影响后续元素
该集合中保存的都是引用类型，即便保存了数组123，也保存的是Integer类型的123，而不是int类型的123
该集合查询效率高，中途增加和删除元素效率低

构造方法：

ArrayList()：创建一个Object类型的空数组。在调用添加方法后，才会更改该数组

大小为10

ArrayList(intinitialCapacity)：创建一个指定容量的Object数组，如果参数为负，会抛出

IllegalArgumentException异常

常用方法：

ArrayList中的常用方法，就是Collection接口和List接口中定义的方法

LinkedList实现类

采用双向链表实现的集合
集合中保存的每个元素也称为节点，除首尾节点外，其余节点都保存了自己的信息外，还保存了其前一个和后一个节点的地址
如果在双向链表的数据结构中插入和删除操作节点时，不会影响其他节点的位置。如添加时新节点时，只需要重写定义新节点的前后节点位置即可
如果要查询某个节点时，需要从头结点或尾结点开始一步步得到目标节点的位置
双向链表在中间插入和删除的效率高，随机读取的效率低

构造方法：

LinkedList()：创建一个空链表

常用方法：

由于LinkedList既实现了List接口，又实现了Deque接口，所以还有Deque接口中的一些方法

ArrayList和LinkedList的区别：

这两个类都是List接口的实现类，保存的元素有序可重复，允许保存null
ArrayList采用数组实现，随机读取效率高，插入删除效率低，适合用于查询
LinkedList采用双向链表实现，插入删除时不影响其他元素，效率高，随机读取效率低，适合用于频繁更新集合

Set接口(无序不重复)

无序集合，元素不可以重复，允许保存null，没有索引。

Set接口中没有自己定义的方法，都是继承于Collection接口中的方法

HashSet实现类

采用哈希表实现
元素不能重复，无序保存，允许保存一个null
本质是一个HashMap对象
使用HashSet集合时，通常要重写实体类中的equals和hashcode方法

构造方法：

HashSet()，创建一个空集合，实际是创建一个HashMap对象。

常用方法：

HashSet中没有属于自定义的方法，都是重写了父接口Set和Collection中的方法。这里参考Collection中的方法即可。

没有与索引相关的方法。

HashSet添加数据的原理

如果两个元素的hashCode相同且equals结果为true，视为同一个对象，不能添加。

每次向集合中添加元素时，先判断该元素的hashCode是否存在

如果不存在，视为不同对象，直接添加
如果存在，再判断equals方法的结果
- 如果false，视为不同对象，可以添加
- 如果true，视为同一对象，不能添加

先判断hashCode，再判断equals，技能保证效率，又能保证不添加重复元素。

TreeSet实现类

特殊的Set实现类，数据可以有序保存，可以重复，不能添加null
采用红黑树(自平衡二叉树)实现的集合
- 二叉树表示某个节点最多有两个子节点
- 某个节点右侧节点值都大于左侧节点值
- 红黑树会经过不停的"变色"、"旋转"达到二叉树的平衡
只能添加同一种类型的对象且该类实现了Comparable接口
- 实现Comparable接口后必须要重写compareTo()方法
- 每次调用添加add(Object obj)方法时，就会自动调用参数的compareTo()方法
compareTo()方法的返回值决定了能否添加新元素和新元素的位置
- 如果返回0，视为每次添加的是同一个元素，不能重复添加
- 如果返回正数，将新元素添加到现有元素之后
- 如果返回负数，将新元素添加到现有元素之前
- 添加的元素可以自动排序

构造方法：

TreeSet():创建一个空集合，实际是创建了一个TreeMap对象

普通方法：

属于Set的实现类，所以能使用Collection和Set中的方法，除此之外，还有独有的方法

TreeSet的应用：

如果要保存的元素需要对其排序，使用该集合。

保存在其中的元素必须要实现Comparable接口，且重写compareTo()方法，自定义排序规则

@Override
public int compareTo(Object o) {
//此时this是当前添加的对象
//o是已存在的集合中的对象
Employee emp = (Employee) o;
//这里用当前员工号-已有员工号,根据员工号升序
return this.getNo()-emp.getNo();
//根据姓名字符串的排序方式排序
// return emp.getName().compareTo(this.getName());
}

Map接口

Map称为映射，数据以键值对的形式保存。保存的是键与值的对应关系。

键称为Key，值称为Value，键不能重复，键允许出现一个null作为键，值无限制。

键和值都是引用类型。

HashMap实现类

构造方法：

HashMap:创建一个空的映射集合，默认大小为16，加载因子为0.75

常用方法：

参考Map中的方法

遍历集合中元素的方式

遍历List集合

普通for循环：

System.out.println("使用普通for循环遍历");
//方式一：普通for循环
for (int i = 0; i < nameList.size(); i++) {//从0遍历到size()
String name = nameList.get(i);//通过get(int index)获取指定索引的元素
System.out.println(name);
}

增强for循环

System.out.println("使用增强for循环遍历");
//方式二：增强for循环
for (String name : nameList) {
System.out.println(name);
}

迭代器

System.out.println("使用迭代器遍历");
//方式三：迭代器
//Collection类型的集合对象.iterator()，获取迭代器
Iterator<String> iterator = nameList.iterator();
// iterator.hasNext()判断集合中是否还有下一个元素
// iterator.next();获取下一个元素
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}

泛型

一种规范，常用于限制集合中元素的类型，省去遍历元素时判断是否为对应类型和转型的过程

在定义集合遍历时，在类后面写上<引用数据类型>

集合类或接口<引用数据类型> 集合变量名 = new 集合实现类();

Collections集合工具类

集合和数组之间的转换

集合转换为数组：使用Collection接口中的toArray()方法

Object[] obj = 集合对象.toArray();
List<Integer> list = new ArrayList();
list.add(123);
list.add(63);
list.add(3);
Integer[] nums =(Integer[]) list.toArray();

数组转换为集合

int[] nums ={11,2,66,3,6,21};
//定义集合对象
List list = new ArrayList();
//遍历数组的同时添加到集合中
for(int i:nums){
list.add(i);
}

文件类File

Java中的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都表示同一个文件

常用方法：

递归遍历文件夹

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);
}
}
}
}

流Stream

在,CXC 中，流用于表示计算机硬盘与内存之间传输数据的通道。

将内存中的数据存入到硬盘中，称为写YTKVG ，也称为输出1WVRWV 。

将硬盘中的数据存入到内存中，称为读TGCF ，也称为输入ƍPRWV 。

流的四个父类的特点

这四个父类都是在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文件字节输出流

构造方法

常用方法：

FileReader文件字符输入流

构造方法

FileReader(String fileName)：根据文件名创建文件字符输入流对象

FileReader(File file)：根据文件对象创建文件字符输入流对象

常用方法：

FileWriter文件字符输出流

构造方法：

常用方法：

BufferedReader缓冲字符输入流(

自带缓冲区(字符数组)的字符输入流。默认字符数组大小为8192，每次最多读取8192个字符。

在读取纯文本文件(txt或md)时，首选该类

构造方法：

常用方法：

BufferedWriter缓冲字符输出流

构造方法：

BufferedWriter(Writer writer)：创建一个自带缓冲区的字符输出流对象，参数为一个Writer对象，Writer是一个抽象类，实际参数为Writer的子类，如FileWriter，在FileWriter中定义要将输入写入的目标文件

BufferedWriter(Writer writer，int size)：创建一个指定缓冲区大小的字符输出流对象

常用方法：

ObjectOutputStream对象字节输出流(序列化)

序列化：将对象转换为文件的过程

被序列化的对象，必须要实现Serializable接口。

这个接口是一个特殊的接口，没有定义任何方法，只是给该类加上标记，表示该类可以被序列化

构造方法：

ObjectOutputStream(OutputStream os) :创建一个对象字节输出流对象，参数为一个字节输出流对象，由于OutputStream是抽象类，所以使用其子类，如FileOutputStream对象，在其中定义要写入的文件

常用方法：

writeObject(Object obj)：将一个对象写入到本地文件中

close()：关闭流对象

ObjectInputStream对象字节输入流(反序列化)

反序列化：将文件转换为对象的过程

构造方法：

ObjectInputStream(InputStream is)：创建一个对象字节输入流对象，参数为一个字节输入流对象，由于InputStream是抽象类，所以使用其子类，如FileInputStream对象，在其中定义要读取的文件

常用方法：

readObject()：读取序列化后的文件，返回类型为Object

close()：关闭流对象

转换流

OutputStreamWriter：将字节输出流转换为字符输出流

InputStreamReader：将字节输入流转换为字符输入流

转换流的使用：

如果只提供了一个字节流，但要向其中写入或读取字符时，就可以使用转换流将字节流转换为字符流。使用字符流读写字符时比字节流更方便

网络编程

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指服务器端

阶段总结

Java高级这部分内容主要是靠记忆。这里面有许多的类需要去了解，比如包装类，字符串String类，Data类等。每个类都有自己的构造方法和许多的普通方法，包括文件file以及集合都一样。个人认为这部分比较难理解的是集合家族还有输入流和输出流。因为集合家族有许多的成员，每个类下都有自己的接口，选取合适的实现类去实现接口不好选择，各个实现类的方法很容易混淆。在IDEA环境下还好，有提示，一旦离开环境后就很茫然了。输入和输出流这方面，主要是流的种类也很多，有字符输入流，文件字节输出流等等，名字比较类似，容易记混淆。还有就是这些流之间转换的过程也比较难理解，看到过程图的时候还勉强能理解，但当自己去做这方面练习题的时候就不是很清楚该使用什么流了，过程之间怎么转换也比较麻烦。其他方面的知识都比较类似，构造方法也比较类似，通过对象.就会提示有什么方法，就算记不住也能根据提示知道方法。