Java 复习总结

这是我在上完《面向对象程序设计：Java》这门课后，对照着 PPT 进行期末复习时所做的总结，其中还包括了老师最后几节课强调的重点。

可能有写的不对的地方，你可以联系我修正，不过目前我可能已经把 Java 的知识忘得一干二净了

Java 语言概述

这个应该不是什么重点，就是选择题会考几道，稍微了解一下即可

Java 程序的编译和运行过程

Java 跨平台和 Java 虚拟机

程序规范

java Test 命令可运行名为 Test.java 的 java 字节码文件
package 语句最多一句，放程序第一句
import 可以多句，放所有类定义之前
public class…公共类定义最多一句，放在同名源文件.java 中
class 类定义可以多句
interface 接口定义可以多句

举例

一个 java 源程序可以是如下结构，该源程序命名为 HelloWorldApp.java

package javawork.helloworld;

import java.awt.*;
import javawork.newcentury;

public class HelloWorldApp{……}

class TheFirstClass{……}

class TheSecondClass{……}

……

interface TheFirstInterface{……}

Java 语言编程基础

标识符命名规范

类名首字母大写，如 BookStore
方法名首字母小写，之后的大写，如 getStudName，调用方法记得加括号，特别是构造方法
常量名全要大写，如 MAX_VALUE
包名要小写，如 utility

转义字符

在 Java 中，不管是 String.split()，还是正则表达式，有一些特殊字符需要转义，这些字符是: (、[、{、/、^、-、$、|、}、]、)、?、\*、+、.。转义方法为字符前面加上" \ "，这样在 split、replaceAll 时就不会报错。不过要注意，String.contains()方法不需要转义

数据类型及大小

Java基本数据类型

基本数据类型
- 数值型
  - 整数类型(byte,short,int,long)
  - 浮点类型(float,double)
- 字符型(char)
- 布尔型(boolean)
引用数据类型
- 类(class)
- 接口(interface)
- 数组([])
- 引用数据类型初始化为 null 时，不引用对象
区别
- 组成
  - 基本数据类型：只包含数值
  - 引用数据类型：不仅包含数值，还包含对数值的操作
- 虚拟机处理方式
  - 基本数据类型：根据变量的实际类型为其分配内存空间
  - 引用数据类型：在内存空间不是存储引用对象的数据，而是对象在堆内存中存放的地址
float 别忘了加 f
long 别忘了加 l
数据类型隐式转换(自动类型转换)
- byte→short→int→long→float→double
- 不能高往低转
强制类型转换(显式)
- (int)，(float) ……
- 可以高往低转
‘a’ + 1 输出 98，“” + ‘a’ + 1 输出 a1

常量声明

方法一

1	`final int AGE = 5；`

方法二

1 2	`final int AGE； AGE = 5；`

常量只能赋值一次

进制

-八进制 0 开头的数字，取值在 0-7

-十六进制 0x 开头的数字，取值在 0-f

运算符

==，&&短路
=，&不短路，前后都要看
==是判断前后地址是否一致的，equals 可能重写用于判断内容
模运算%的结果和被除数有关，被除数是正数，则模结果是正数，被除数是负数，结果是负数
逻辑运算中，^表示异或，!表示非
ture，false 首字母小写
位运算中，~表示取反
移位运算符
- 左移：<< (低位添 0 补齐)
- 带符号右移：>> (高位添符号位)
- 无符号右移：>>> (高位添 0 补齐)

switch

case 后面是常量，无 break 就会顺序执行
常量中只能是 int，short，byte，char 类型

类和对象

访问修饰符

可见范围

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类(外部类)
default (即缺省，什么也不写，不使用任何关键字): 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类(外部类)
public : 对所有类可见。使用对象：类、接口、变量、方法

定义

[修饰符] class 类名[extends 父类][implements 接口名]
{
  类成员变量声明
  类方法声明
}

类成员变量和方法可以交替定义
类中也可以有 main 方法

构造方法

方法名与类名相同。没有返回值类型。没有具体的返回值
构造方法前面不能写 void 等标识，写上 void 后就是普通方法了
构造方法前面可以写修饰符，不能写标识符
无构造方法时，系统默认创建无参构造方法
有有参构造方法时，系统就不会自动创建构造方法了，得自己定义无参构造方法
调用构造方法时会自动调用 super()父类无参构造方法

包

必须是第一句
java.lang 是默认导入的

修饰符

类成员变量加 static 说明是类变量，是公有的

class ABCD {
    char data;
    static int share_data;
}

class Demo {
    ABCD a, b, c, d;
}

a.data, a.share_data, ABCD.share_data 是对的，不能写 ABCD.data
不能将 static 方法、final 方法或者类的构造器方法声明为 abstract
没 static 的变量得用对象来调用如 new ABCD().data
静态方法只能访问静态成员变量。会编译错误
静态方法和变量属于类
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以

其他

data instanceof car 判断对象 data 是否为 car 类型，返回布尔值
基本类型的函数参数传递传的是拷贝，引用类型传的是地址(类、接口、数组)
注意函数处理字符串 String 类型时是不会改变这个量的
String 和 StringBuffer 作为参数为什么不同？
- String 生成实例之后他的值无法修改，如果对它进行修改会产生新的对象，所以 String 的地址传入函数内部，函数内部对它指向的值进行操作，最终却生成了另外一个对象，而上面所说无法对原 String 的地址修改，所以对于新生成的 String 对象无法影响原来的 String 对象，并且它的生命周期只在函数内部

可变参数

public void f(int … x) 其中…用来表示可变参数，适用于参数个数不确定，类型确定的情况，java 把可变参数当做数组处理
数组的长度用.length 表示

继承和多态

[修饰符] class 子类名 extends 父类名
- 修饰符：可选，用于指定类的访问权限
- 可选值为 public、abstract 和 final
- 子类名：又称为派生类(derived class)、孩子类(child class)必选，用于指定子类的名称，类名必须是合法的 Java 标识符。一般情况下，要求首字母大写
- extends 父类名：又称超类(superclass)、基类(base class)，必选，用于指定要定义的子类继承于哪个父类
只支持单继承，不允许多重继承
可以多层继承，即一个类可以继承某一个类的子类，如类 B 继承了类 A，类 C 又可以继承类 B，那么类 C 也间接继承了类 A
子类继承父类的成员变量和成员方法，但不继承父类的构造方法
不能为构造方法指定返回值类型，即使 void 也不行；如果程序中定义的某个方法名与所属类名同名且具有返回值类型，则这个方法就是一个普通方法，不是构造方法。一般不提倡
创建子类对象时，系统调用子类构造方法，但在子类构造方法中会首先插入父类的构造方法的调用，以初始化从父类继承的数据成员，但只适应于默认构造方法
- 如果父类没有默认构造方法或默认构造方法不能在子类访问，或希望调用有参构造方法，需使用 super 关键字
super()或 this()必须是写在第一行
实例初始化块用于初始化实例变量。实例初始化块会在初始化类的一个实例时执行，而且在构造函数之前就执行。并且每次创建类的对象时它们都会执行。多个实例初始化块会从上到下执行
- 构造函数、非静态初始化块、静态代码块都是用于初始化，三者的执行顺序依次是：静态代码块>构造代码块>构造函数

public class TestInit {
    {  System.out.println(“类TestInit的实例化初始化块”);  }
    static{  System.out.println(“类TestInit的静态初始化块”);  }

    public TestInit() {
        new Child();
    }

    public static void main(String[] args) {
        new TestInit();
    }
}

class Child extends Father {
    {  System.out.println(“类Child的实例化初始化块”);  }
    static{  System.out.println(“类Child的静态初始化块”);  }

    Child () {  System.out.println(“类Child的的构造方法”); }
}

class Father {
    private int age;
    {  System.out.println(“类Father的实例化初始化块”);  }
    static{  System.out.println(“类Father的静态初始化块”);  }

    Father () {  this(20);  System.out.println(“类Father的的构造方法”); }

    Father (int age) {  this.age=age;  System.out.println(“类Father的带参构造方法”); }
}

先加载父类的静态初始化块，再加载子类静态初始化块
创建对象时都会执行实例初始化块

super

操作被隐藏的成员变量和被覆盖的成员方法
调用父类的构造方法

多态

重载

方法的重载是指在一个类中，出现多个方法名相同，但参数个数或参数类型不同的方法，则称为方法的重载
- 在重载的方法中，方法签名唯一标识一个方法。方法签名即包括方法名和形参类型，不包括形参名字
- 被重载的方法必须改变参数列表，参数的个数或者参数的类型；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法可以在同一个类中或者子类中被重载；
- 无法以返回值类型作为方法重载的区分标准

覆盖(重写)

Java 语言中，只有实例方法可以覆盖(或重写)，类方法(即静态方法)不可以被覆盖
- 方法覆盖时，必须注意子类中的方法应该与父类中的方法有相同的方法名，返回值类型和形参类型列表。注意与方法重载的区别，重载时参数类型不同
  子类如果要调用父类中被覆盖的方法，需要使用 super 关键字；如果没有被覆盖，可以直接调用
- **方法覆盖时，不能降低其访问权限。**降低会编译错误，但是可以提升其访问权限
- 子类可以改写父类的数据成员和非静态方法，java 中改写成员的方式称为成员隐藏。当父类的成员被隐藏时，子类直接访问的是自己定义的成员，可以用 super 访问隐藏成员；当父类的静态成员被隐藏，可以使用父类名访问该成员
对于 java 中的父类和子类含有相同的成员变量，数值如何判断：
- (1)子类对象在初始化时，子类对象和父类对象在两个不同内存区域。子类，父类含有相同的成员变量，数值看引用型变量所属的类，即左边
  (2)父类独有方法改变成员变量值，则改变的是父类中的数据
  (3)子类重载父类方法，调用的是子类的方法，改变的是子类数据
  (4)如果在多态，即 Parent c = new Child(),子类重载父类方法，则 c.方法( ) 调用的是子类的方法，改变的子类变量数据，c.变量，显示的是父类数据，还是未改变的。
  (5)子类声明与父类同名的变量时，实际上是子类隐藏了父类的同名变量，这时候如果要访问父类的同名变量，可以使用 super 关键字，如 super.变量

类型转换(向上转型)(向下转型)

当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。如果子类重写了父类的方法，在调用该方法的时候，必定是使用子类中定义的这些方法，这叫做动态链接或者动态调用；如果引用子类中新的方法，在编译时，系统会提供找不到方法的错误
父类一般不能转换成子类；但是，如果一个父类对象实例实际引用的是一个子类对象，就可以使用强制类型转化将父类对象转换为子类类型
如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现 java.lang.classcastException 的错误，她可以使用 instanceof 来避免出此类错误

特殊类

final 类

关键字 final 可以用来修饰变量(包括数据成员和局部变量)、方法和类，被 final 修饰的变量、方法和类是最终的、不可改变的

final 方法
- 关键字 final 修饰的方法时最终的方法，在继承过程中不能被子类覆盖。构造方法不存在继承问题，不能用 final 关键字修饰
- final 修饰的方法可以被重载，但是不可以被覆盖
- 类的私有方法不能被覆盖，相当于做了 final 处理
final 类
- 用 final 修饰的某个类，这个类就是终极的，不能被其他类继承
- final 类中的所有方法都是 final 的，但数据成员可以不是 final 的

抽象类

抽象类不能被实例化，只能被子类继承
如果一个子类没有实现抽象父类中所有的抽象方法，则子类也成为一个抽象类
如果一个子类实现抽象父类中所有的抽象方法，则子类不是一个抽象类
我们可以将一个没有任何抽象方法的类声明为 abstract，避免由这个类产生任何的对象
构造方法、static 方法、private 方法、final 方法不能被声明为抽象的方法。

内部类

Java 语言允许在类中定义内部类，内部类就是在其他类内部定义的子类

内部类的作用：
- 1、隐藏你不想让别人知道的操作，也即封装性
  2、一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！
成员内部类
- 成员内部类无条件访问外部类的属性和方法
- 外部类访问内部类属性和方法必须要创建一个内部类对象，然后通过该对象访问内部类的属性或方法
- 如果成员内部类的属性或者方法与外部类的同名，将导致外部类的这些属性与方法在内部类被隐藏，也可按照该格式调用：外部类.this.属性/方法
- 创建内部类

1
2
3

Outer  out = new Outer();
Outer.Inner  inner = out.new Inner();
inner.print();

成员内部类前可加上四种访问修饰符
- private：仅外部类可访问
- protected：同包下或继承类可访问
- default：同包下可访问
- public：所有类可访问
局部内部类
- 局部内部类存在于方法中。他和成员内部类的区别在于局部内部类的访问权限仅限于方法或作用域内
静态内部类
- 静态内部类和成员内部类相比多了一个 static 修饰符。它与类的静态成员变量一般，是不依赖于外部类的。同时静态内部类也有它的特殊性。因为外部类加载时只会加载静态域，所以静态内部类不能使用外部类的非静态变量与方法
匿名内部类
- 匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或实现一个接口。匿名内部类不能是抽象类
- 匿名内部类不能定义构造方法。由于匿名内部类没有类名，所以无法定义构造方法，但匿名内部类可以有初始化块，可以通过初始化块来完成构造方法需要完成的工作
- 匿名内部类不能定义任何静态成员、方法和类。匿名内部类不能是 public, protected, private, static
- 所有内部类会在编译的时候产生相对应的 class 文件，非匿名内部类类名规则为 OutClass$InnerClass (外部类类名与内部类类名中间用$连接) 匿名内部类类名则为 OutClass$数字(OutClass$1，OutClass$2，OutClass$3)

接口

如果一个抽象类中的所有方法都是抽象的，我们就可以将这个类用另外一种方式来定义，也就是接口定义
接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现
一个源代码文件中，只允许出现一个 public 的接口和类，且该接口和类必须和文件名相同
如果一个类实现了某个接口，这个接口可以看作这个类的父类。子类对象类型和接口类型相互转换

[修饰符] interface 接口名 [extends 父接口名列表] {
    [public] [static] [final] 常量;
    [public] [abstract] 方法;
}

和 public 类一样，public 接口也必须定义在与接口同名的文件中
接口中所有的方法都是 public abstract
接口中可以有数据成员，这些成员默认都是 public static final。可以用类名或对象名直接访问！

实现接口

1	`[修饰符] class <类名> [extends 父类名][implements 接口列表] {}`

当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔
在类实现接口时，必须实现接口中的所有方法。方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致！

object

toString 方法
- 主要作用返回当前本身信息的字符串，默认的情况下返回的字符串由该对象所属的类名、at 符号@和该对象哈希码的无符号十六进制表示组成，实际上没有什么实用价值

包装类

valueOf 方法：静态方法 valueOf 在所有的包装类中都有定义。该方法创建一个相应类的新对象，并将对象初始化参数指定值
转换方法：除 Character 类外，其他包装类中都定义了将字符串转换为相应的基本数据类型的静态方法。如 int i=Integer.parseInt(“2”);

一维数组

声明数组时，不能指定其长度，编译时将出错
只能在声明数组的同时进行静态初始化
动态初始化只专注于为数组申请对应长度的空间
默认值的规定如下：
a) boolean 类型的默认值是 false
b) 其它 7 种基本数据类型是 0。其中 char 的默认值是编码为 0 的字符，而不是字符 0
c) 引用数据类型的初始值是 null
int x[] = new int[]{1,2,3};
x.length 得到数组长度

下面不是创建数组的正确语句
A float f[][]=new float[6][6]
B float f[]=new float[6]
C float f[][]=new float[][6]
D float [][]f=new float[6][]
C是错误的，先有行才可以

for(数据类型 变量名：数组名)
    语句

eg:
int[] arr={1,2,3,4};
for(int i:arr)
    System.out.println(i);

1
2
3

int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers,luckyNumbers.length)
将一个数组的所有值拷贝到新的数组中，要使用Arrays类的copyOf方法
直接写=的话是传地址

二维数组

int[][] days = new int [2] [3];
int[][] balances={{16, 3, 2, 13}, {5, 10, 7, 9}, {3 , 29, 39, 15}, {12, 3, 6, 2}};

for (int x[]: arr){
    for (int y:x)
        System.out.print(y+” ”);
    System.out.println();
}
// 遍历二维数组

java 中并没有真正的多维数组，只有数组的数组， Java 中多维数组不一定是规则矩阵形式

字符串

.length()得到长度
字符串比较的方法有 equals()、equalsIgnoreCase()、startsWith(),endsWith()、regionMatches()、compareTo(),compareToIgnoreCase()等方法
public String substring(int beginIndex)

该方法将获得一个当前字符串的子串,该子串是从当前字符串的 beginIndex 处截取到最后所得到的字符串

public String substring(int beginIndex,int endIndex)

该方法将获得一个当前字符串的子串,该子串是从当前字符串的 beginIndex 处截取到 endIndex-1 结束所得到的字符串
public String replace(char oldChar,char newChar)
返回一个新的对象，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的
public String replaceAll(String old ,String new)
使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。例如 replaceAll(“ +”,“”)去掉所有空格
public String trim()
返回一个新的字符串。这个字符串将删除了原始字符串头部和尾部的空格
字符串大小写转换，申明格式如下：
public String toUpperCase()
public String toLowerCase()
转换为字符串数组，申明格式如下：
public char[ ] toCharArray( )

Arrays 类

Arrays.fill 函数将某个值赋值给数组全部或部分元素
Arrays.toString(Arrays.deepToString) 函数打印数组元素

int[] arr = new int[5];//新建一个大小为5的数组
Arrays.fill(arr,4);//给所有值赋值4
int[] arr = new int[5];//新建一个大小为5的数组
Arrays.fill(arr, 2,4,6);//给第2位(0开始)到第4位(不包括)赋值6
String str = Arrays.toString(arr); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[0, 0, 6, 6, 0]

int[] arr = {3,2,1,5,4};
System.out.print(arr);//直接将数组打印输出
//输出：[I@7852e922 (数组的地址)
String str = Arrays.toString(arr); //
Arrays类的toString()方法能将数组中的内容全部打印出来
//System.out.print(str);
//输出：[3, 2, 1, 5, 4]

Arrays.copyOf(Arrays.copyOfRange) 函数复制数组
Arrays.equals(Arrays.deepEquals) 函数比较数组
Arrays.sort 函数对数组元素从小到大排序

int[] intArray = new int[] { 4, 1, 3, -23 };
Arrays.sort(intArray);
//输出： [-23, 1, 3, 4]
String[] strArray = new String[] { “z”, “a”, “C” };
Arrays.sort(strArray);          //符串排序，先大写后小写
//输出： [C, a, z]
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
//输出： [a, C, z]        //严格按字母表顺序排序，也就是忽略大小写排序
Arrays.sort(strArray, Collections.reverseOrder());     //反向排序
//输出：[z, a, C]

Arrays.binarySearch 函数在数组中检索目标元素，并返回该元素的下标
- 下标从 0 开始

int[] arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 30));
//输出：2 (下标索引值从0开始)

int[] arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 36));
//输出：-4 (找不到元素，返回-x，从-1开始数，如题，返回-4)

int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 0,3,30));
//输出：2 (从0到3位(不包括)找30，找到了，在第2位，返回2)

copeOf()和 Arrays.copeOfRange()方法

public int indexOf(int ch)
public int indexOf(int ch,int fromIndex)
public int indexOf(String str)
public int indexOf(String str,int fromIndex)

public int lastIndexOf(int ch)
public int lastIndexOf(int ch,int fromlndex)
public int lastIndexOf(String str)
public int lastIndexOf(String str,int fromIndex)
上述四个重载的方法分别用于在字符串中定位指定的字符和字符串最后出现的位置，并且在上述方法中可以通过fromIndex来指定匹配的起始位置。如果没有检索到字符或字符串,该方法返回的值是-1

StringBuffer/StringBuilder 常用方法

toString()
append()
charAt()
deleteCharAt()
delete(2,4)/delete(2)从哪删到哪
insert(2,“cc”)
indexOf(“ba”,2)/indexOf(“ba”)
lastIndexOf()也有两种
reverse()反转字符串
length()
从性能和速度方面

StringBuilder > StringBuffer > String
从线程安全的角度去看

StringBuffer 是线程安全的，而 StringBuilder 是线程不安全的

异常处理

Throwable 类

Throwable 类的常用方法
- public String toString()：返回描述当前异常对象信息的字符串
  public String getMessage()：返回描述当前异常对象信息的详细信息
  public void printStackTrace()：没有返回值，屏显当前异常对象使用堆栈的轨迹，即程序先后调用了哪些方法，使得运行过程产生了这个异常对象
所有的检查性异常都继承自 java.lang.Exception；所有的非检查性异常都继承自 java.lang.RuntimeException
- 常见的检查性异常：输入输出异常(IOException)、文件不存在异常(FileNotFoundException)、SQL 语句异常(SQLException)等
- 常见的运行时异常：空指针异常(NullPointerException)、除零异常(ArithmeticException)、数组越界异常(ArrayIndexOutOfBoundsException)等;
ArithmeticException 当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例
ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引
ClassCastException 当试图将对象强制转换为不是实例的子类时，抛出该异常
StringIndexOutOfBoundsException 此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小

class MyException extends Exception {
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

无论有无异常，最后必须执行 finally 语句中的语句体
throw new Exception(“年龄不能为负数！”);
throws Exception;
在 try 块中即便有 return，break，continue 等改变执行流的语句，finally 也会执行
finally 中的 return 会覆盖 try 或者 catch 中的返回值
finally 中的 return 或异常会抑制(消灭)前面 try 或者 catch 块中的异常

输入和流

字节流
- 处理单元为 1 个字节，操作字节和字节数组
  字节流是最基本的流，文件的操作、网络数据的传输等都依赖于字节流
字符流
- 处理的单元为 2 个字节的 Unicode 字符，可以国际化
  任何涉及文本的数据类型都应该使用字符流，包括文本文件、网页及其他常见的文本类型
read()读到-1 结束
readLine()读到 null 结束
重点如下

try {
    File f = new File("123.txt");
    FileWriter fw = new FileWriter(f);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.write("abc");
    bw.newLine();
    bw.write("123");
    bw.newLine();
    bw.flush();
    bw.close();
    fw.close();
    FileReader fr = new FileReader(f);
    BufferedReader br = new BufferedReader(fr);
    int i = 1;
    String str;
    while ((str = br.readLine()) != null) {
        System.out.println(i++ + "行：" + str);
    }
    br.close();
    fr.close();
}catch(
Exception e)
{
    System.out.println(e);
}

Reader 类

方法名称	功能描述
read()	读入一个字符。若已读到流结尾，则返回值为 −1
read(char[])	读取一些字符到 char[]数组内，并返回所读入的字符的数量。若已到达流结尾，则返回-1
reset()	将当前输入流重新定位到最后一次调用 mark() 方法时的位置
skip(long n)	跳过参数 n 指定的字符数量，并返回所跳过字符的数量
close()	关闭该流并释放与之关联的所有资源。在关闭该流后，再调用 read()、ready()、mark()、reset() 或 skip() 将抛出异常

Writer 类

方法名称	功能描述
write(int c)	将字符 c 写入输出流
write(String str)	将字符串 str 写入输出流
write(char[] cbuf)	将字符数组的数据写入到字符输出流
flush()	刷新当前输出流，并强制写入所有缓冲的字节数据
close()	向输出流写入缓冲区的数据，然后关闭当前输出流，并释放所有与当前输出流有关的系统资源

集合和泛型

List 中的方法

get(2)
indexOf(‘a’)
lastIndexOf(‘a’)
size()返回结点个数
set(1,‘a’)替换数据
contains(‘a’)是否含有
LinkList 中新增的
- addFirst(‘a’)表头加结点
- addLast(‘a’)表尾加结点
- getFirst()获得第一个结点数据
- getLast()
- removeFirst()
- removeLast()
- clone()克隆

迭代器

Iterator iterator()

hasNext()
next()
remove()

排序和查找

Collections.sort(intList, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
    // 返回值为int类型，大于0表示正序，小于0表示逆序
    return o2-o1;
    }
});

方法名称	功能简介
put(K key, V value)	向集合中添加指定的键—值映射关系
putAll(Map<? extends K, ? extends V> t)	将指定集合中的所有键—值映射关系添加到该集合中
containsKey(Object key)	如果存在指定键的映射关系，则返回 true；否则返回 false
containsValue(Object value)	如果存在指定值的映射关系，则返回 true；否则返回 false
get(Object key)	如果存在指定的键对象，则返回与该键对象对应的值对象；否则返回 null
keySet()	将该集合中的所有键对象以 Set 集合的形式返回
values()	将该集合中的所有值对象以 Collection 集合的形式返回
remove(Object key)	如果存在指定的键对象，则移除该键对象的映射关系，并返回与该键对象对应的值对象；否则返回 null
clear()	移除集合中所有的映射关系
isEmpty()	查看集合中是否包含键—值映射关系，如果包含则返回 true；否则返回 false
size()	查看集合中包含键—值映射关系的个数，返回值为 int 型
equals(Object obj)	用来查看指定的对象与该对象是否为同一个对象。返回值为 boolean 型，如果为同一个对象则返回 true，否则返回 false

多线程技术

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流

一个进程可以包含多个线程，每个线程独立运行以执行特定的任务，同一进程内的多个线程间共享内存等资源

构造方法

public Thread();
public Thread(Runnable target);
public Thread(String name);
public Thread(ThreadGroup group, Runnable target);
public Thread(Runnable target, String name);
public Thread(ThreadGroup group, Runnable target, String name);

group 指的是该线程所属的线程组；
target 指的是提供线程体的对象。Java.lang.Runnable 接口中定义了 run()方法，实现该接口的类的对象可以提供线程体，线程启动时该对象的 run()方法会被调用.
name 指的是线程名称。Java 中的每个线程都有自己的名称，如果 name 为 null，java 会自动给线程赋一唯一的名称

类方法

currentThread() 返回正在运行的 Thread 对象
- Thread[main,5,main]
yield() 停止运行当前线程，将 CPU 控制权主动移交到下一个可运行线程
sleep(int n) 让当前线程睡眠 n 毫秒,n 毫秒后,线程可以再次运行

实例方法

start(int millsecond) 为本线程建立一个执行环境，然后调用本线程的 run()方法
run() 在该方法中编写运行本线程将要执行的代码，也是Runnable 接口的唯一方法。当一个线程初始化后，由 start() 方法来调用它，一旦 run()方法返回，本线程也就终止了
stop() 让某线程马上终止，系统删除本线程的执行环境
suspend() 将线程挂起暂停运行，系统不破坏线程的执行环境，可以用 resume()来恢复本线程的执行
resume() 恢复被挂起的线程进入可运行状态
setPriority(int p) 给线程设置优先级 1<=p<=10
getPriority() 返回线程的优先级
setName(String name) 赋予线程一个名字 name
getName() 取得由 setName()方法设置的线程名字的字符串
wait(long timeout) 停止当前线程，直到另外的线程对这个对象使用 notify()或 notifyAll()方法
notify()或 notifyAll() 唤醒指定对象的一个或所有线程

实现多线程的方法

举例：在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为:
public class ThreadSubclassName extends Thread {
    public ThreadSubclassName() {
        // 编写子类的构造方法，可缺省
    }

    public void run() {
        // 编写自己的线程代码
    }
}

举例：在实现Runnable接口的类MyThread中实现run()方法
public class MyThread implements Runnable {
    public void run() { // 编写自己的线程代码
    }
}
(续)举例：创建实现Runnable接口的类MyThread 的对象实例:
Mythread  mt = new Mythread();
新创建线程对象，将指向Runnable类的实例，使用Runnable类实例为线程提供run()方法：
Thread  t = new Thread(mt);
然后就可启动该线程对象表示的线程：
t.start(); // 启动线程

其他

System.exit(0)表示正常关闭虚拟机

学习相关

#JAVA

Hexo 使用指南上一篇

我的第一篇博客下一篇

Java 复习总结

Java 语言概述

Java 程序的编译和运行过程

Java 跨平台和 Java 虚拟机

程序规范

举例

Java 语言编程基础

标识符命名规范

转义字符

数据类型及大小

常量声明

进制

运算符

switch

类和对象

访问修饰符

定义

构造方法

包

修饰符

其他

可变参数

继承和多态

super

多态

重载

覆盖(重写)

类型转换(向上转型)(向下转型)

特殊类

final 类

抽象类

内部类

接口

实现接口

object

包装类

一维数组

二维数组

字符串

Arrays 类

StringBuffer/StringBuilder 常用方法

异常处理

输入和流

重点如下

集合和泛型

List 中的方法

迭代器

排序和查找

多线程技术

构造方法

类方法

实例方法

实现多线程的方法

其他