第三章
1. Java不支持无条件的调转goto语句。
2. 循环中常用的跳转语句：break和continue。
3. Java中提供的循环语句有三种：while，do while，for。
4. Switch(整型/字符)。
5. 接受键盘输入的语句：ch=(char)System.in.read()；
6. 异常(Exception)又称为例外，是特殊的运行错误对象，对应着Java语言特定的运行错误处理机制。
7. 把生成异常对象并提交的过程称为抛出(throw)一个异常。
8. 运行时系统在方法的调用栈中查找，从生产异常的方法开始进行回溯，直到找到包含相应异常处理的方法为止，这一个过程称为捕获(catch)。
9. 根据错误的严重性，分为错误(致命的)和异常(非致命的)。
10. Exception类是所有异常的父类，Error类是所有错误的父类，这两个类都是Throwable的子类。
11. Exception又分为：检查型异常和非检查型异常。
12. 非检查型异常(因错误导致或者不希望程序捕获)，继承来自RuntimeException的异常，不需要进行声明，并且编译器对其不做检查。
13. 检查型异常：
(1)ArithmeticException：整数除法中，除数为0。
(2)NullPointerException：一个对象还没有实例化。
(3)NegativeArraySizeException：创建数组时数组元素是负数。
(4)ArrayIndexOutOfException：下标越界。
(5)ArrayStoreException：程序试图存取数组中错误的数据类型。
14. 非检查型异常：
(1)FileNotFoundException：试图存取一个并不存在的文件。
(2)IOException：通常的I/O错误。
15. 处理异常的办法：声明抛出异常(throws)，捕获异常(try{}catch(){}finally{}))。
16. Finally块的作用通常用于释放资源，Finally不是必需部分，如果有finally部分，不论是否捕获到异常，总要执行finally后面的语句。
17. 在catch块的内部，可用下面的方法处理异常对象：
(1)getMessage()：返回一个字符串对发生的异常进行描述。
(2)PrintStackTrace()：给出方法的调用序列，一直到异常的产生位置。
第四章
1. 继承是一种由已有的类创建新类的机制，是面向对象程序设计的基石之一。一个新类可用从现有的类中派生，这个过程称为类继承。派生出的新类称为已有类的子类，已有类称为超类(父类)。
2. Java可以通过实现接口来实现多继承功能。
3. Java只支持单继承，即每个子类只能有一个直接父类，类的层次结构为树状结构，Object类为树的根节点。
4. Java要求声明的每个类都有父类，当没有显示父类的时候，父类隐藏为java.lang包中的Object类。
5. 关键字extends：说明要声明的类需要继承父类的属性和行为。
6. 子类不能直接访问从父类中继承的私有属性及方法，但可以使用公有(及保护)方法进行访问。
Eg：public class B
{
Public int a=10;
Private int b=20;
Protected int c=30;
Public int getB()
{
Return b;
}
}
Public class A extends B
{
Public int d;
Public void tryVariables()
{
System.out.println(a);//允许
System.out.println(b);//不允许
System.out.println(getB());//允许
System.out.println(c);//允许
}
}
所有，b是从类B继承而来的，由于b是私有属性，不能在A中直接存取，但可以使用继承类的共有方法getB()取得。
7. 隐藏和覆盖是指子类对从父类继承来的属性变量及方法可以重新定义。
8. 属性的隐藏：子类对父类继承来的属性变量重新加以定义，则父类继承来的属性将被隐藏。
9. 隐藏：是指子类拥有两个相同名字的变量，一个继承父类，一个由自己声明。
10. 当子类执行继承自父类的操作时，处理的是继承自父类的变量，而当子类执行它自己声明的方法时，所操作的就是它自己声明的变量，而把继承自父类的变量“隐藏”起来。
11. 访问被隐藏的父类域：调用从父类继承的方法(则操作的是从父类继承的域)，使用super.域名。
12. 子类不能继承父类中的静态变量，但是可以对父类中的静态变量进行操作。
13. 调用自己的构造方法用this，调用父类用super，final终结。
14. 在方法的覆盖中，由于同名方法隶属于不同的类，所以要解决调用时如何区分它们：只需在方法名前面使用不同的类名或不同的对象名即可。
15. 构造方法是类的一种特殊方法，它可以重载，但不能从父类那里继承。它的名字必须与它所在的类的名字完全相同，并且不返回任何数据类型，也不能是void类型。
16. 子类不能从父类继承构造方法。
17. 如果在子类的构造方法的声明中没有明确调用父类的构造方法，则系统在执行子类构造方法时会自动调用父类的默认构造方法(即无参的构造方法)。
18. 如果在子类的构造方法的声明中调用父类的构造方法，则调用的语句必须放在子类构造方法的第一行。
19. Object类是Java程序中所有类的直接或间接父类，也就是类库中所有类的父类，处在类层次最高点。所有其他的类都是从Object类派生出来的，所以Object类包含所有Java类的公共属性。
20. Object类中的方法有clone()，equals()，getClass()，toString()，hashCode()。
21. Equals：两个对象是否具有相同的类型及相同的属性值；
==：两个引用变量指向的是同一个对象
Eg：BankAccount a =new BankAccount(“Bob,123456,100.00f);
BankAccount b =new BankAccount(“Bob,123456,100.00f);
BankAccount c=a;
a==b;//NO a==c;//Yes
a.equals(b);//Yes a.equals(c);//Yes
22. Object是类层次结构中的树根节点，所有的其他类都是Object类的子类。
23. @Override：重载父类
24. Final的四“不”：
(1)Final不可能有派生类(即final只可能是这棵树上的叶子节点)；
(2)Final不能被继承；
(3)Final一旦定义初始化便不能进行修改；
(4)Final不能被当前的子类重载
25. 被声明为final的类通常是一些有固定作用，用来完成某种标准功能的类，不能被继承以达到修改的目的。
26. 所谓的抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。
27. 抽象类用的关键字是abstract。
28. 抽象类也可以包括抽象方法，但是没有方法的实现。
29. 抽象类也可以包含非抽象方法，但不能在非抽象的类中声明抽象方法。
30. 只有抽象类才能有具体的抽象方法。
31. abstract声明了一种没有具体对象的，声明一种仅有方法头，而没有具体的方法体和操作实现的抽象方法，为该类的子类声明一个方法的接口标准。
32. 抽象类可以包括被它的所有子类共享的公共属性。在抽象类中可以包括被它的所有子类共享的公共行为。
33. 泛型类的定义是在类名后面加上“”，泛型方法的定义就是在方法名前加上“”。
34. 当要获取函数的返回值并且使用时，必须将其返回值强制转换为原类型或接口，然后才可以调用原类型的方法。(p123)
Eg:GeneralType i=new GeneralType(2);
GeneralType d=new GeneralType(0.33);
i.object=(Integer)i.getObj();//i.object=2
d.object=(Integer)i.getObj();//double类型不能转成int型
35. (p124)
gm.printClassName(“hello”);//java.lang.String
gm.printClassName(3);//java.lang.Integer
gm.printClassName(3.0f);//java.lang.Float
gm.printClassName(3.0);//java.lang.Double
36. 通用符泛型：GeneralType
语法：eg：GeneralType i;
37. 不能将General 类型的变量当做参数传递给General 。
38. 在java中“？”表示一种通配符。
39. “属于”关系是用继承来表达的，而“包含”关系是用合成来表达的。
第五章
1. 接口关键词：interface。
2. 接口(interface)可以说成是抽象类的特例。接口中的所有方法都必须是抽象的，接口中的方法定义默认为public abstract 。接口中的变量是全局常量，即public static final修饰的。
3. 接口和抽象类的区别：
(1)抽象类里可以有构造方法，而接口内不能有构造方法。
(2)抽象类中可以有普通成员变量，而接口中不能有普通成员变量。
(3)抽象类中可以包含非抽象的普通方法，而接口中所有的方法必须是抽象的，不能有非抽象的普通方法。
(4)抽象类中的抽象方法的访问类型可以是public ，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
(5)抽象类中可以包含静态方法，接口内不能包含静态方法。
(6)抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static类型，并且默认为public static类型。
(7)一个类可以实现多个接口，但只能继承一个抽象类。
4. 接口不规定方法体，但也包含了数据成员，但它们都默认为static和final。
5. Java接口中只声明原型，而没有直接定义方法的内容，接口声明的方法都是抽象方法，只提供一种形式，并不实现具体的细节。
6. 在接口的声明中，Java允许省略声明数组成员的final关键字，方法的public及abstract关键字。
7. 接口里只有抽象方法，它只要声明而不需要定义处理方式。所以接口也没有可能像一般类一样，使用new运算符就可以直接产生对象。
8. 为了生存与一个特定的接口(或一组接口)相符的类，要使用implements(实现)关键字。注意在实现一个接口的时候，来自接口的方法必须声明成public。
9. Java不允许一个类有多个父类，但允许一个类可以实现多个接口，(用implements实现)通过这种方式实现多重继承。
10. 接口的扩展用关键字extends。
11. 类型转换也称为塑型。
12. 对象只能被塑型为：
(1)任何一个父类类型。即任何一个子类的引用(或对象)都可以被当成一个父类引用变量(或对象)来对待，因为子类继承了父类的属性及行为；但反过来却不成立。
(2)对象所属的类实现的一个接口。
(3)或者回到它自己所在的类。
13. 隐式(自动)的类型转换：
对于基本数据类型，相容类型之间存储类型低的会自动向存储类型高的类型转换；对于引用类型，当一个类需要被塑型成更一般的类(父类)或接口时，系统将会自动进行塑型。
Eg：Employee emp;
Emp=new Manager();
对象也可以被塑型为对象所属类实现的接口。
Eg：Car jetta=new Car();
Insurable item=jetta;
14. 强制类型转换：
当隐式类型转换不可以时，需要进行显示的类型转换。
Eg：(int)871.3456
对于引用变量，通过强制塑型，将其还原为本来的类型。
Eg：Employee emp;
Manager man;
Emp=new Manager();
Man=(Manager)emp;
15. 塑型主要用于的场合：赋值转换，方法调用转换，算数表达式转换，字符串转换。
16. 在方法的内部中，只有Object类中声明的方法才能发送给形参变量。
17. 方法的查找：
(1)实例的查找
Eg：Manager man =new Manager();
Employee emp1=new Employee;
Employee emp2=Employee(man);
emp1.computePay();//调用Employee类中的computePay()方法
man.computePay();//调用Manager类中的computePay()方法
emp2.computePay();//调用Manager类中的computePay()方法
(2)类查找
Eg：Manager man =new Manager();
Employee emp1=new Employee;
Employee emp2= Employee(man);
Manager.expenseAllowance();//in Manager
man.expenseAllowance();//in Manager
Employee.expenseAllowance();//in Employee
emp1.expenseAllowance();//in Employee
emp2.expenseAllowance();//in Employee!!!!!
18. 多态性是指不同类型的对象可以响应相同的消息。
19. Instance of用法：是用来在运行时指出对象是否是特定类的一个实例
用法：result = object instanceof class
参数：Result：布尔类型。
Object：必选项。任意对象表达式。
Class：必选项。任意已定义的对象类。
说明：如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。
20. 将一个方法调用到同一方法主体连接到一起就称为“绑定”。根据绑定的时期不同，可以分为“早期绑定”和“后期绑定”。早期绑定：就是在程序运行一起绑定。后期绑定：绑定在运行期间，也称为“动态绑定”或“运行期绑定”。
21. 利用向上塑型技术，一个父类的引用变量可以指向不同的子类对象，而利用动态绑定技术，可以在运行时根据父类引用变量所指对象的实际类型执行相应的子类方法，实现多态性。
22. 二次分发：即对输出消息的请求被分发两次。
23. 一个派生类只能访问它自己的成员，不能访问具有private属性的基类成员。
24. 若没有在派生类构造方法中明确指定对基类构造方法的调用，则系统会自动调用基类的默认构造方法(无参数)。
25. super.toString调用父类Ball的toString方法输出类Ball中声明的属性值，由于在子类中不能直接存取父类中声明的私有数据成员，这是显示父类数据成员的唯一办法。
26. 构造方法的调用次序：调用基类的构造方法，按声明顺序调用成员初始化模块，调用派生类构造方法。
第六章
1. Java中没有标准的输入输出语句，通过使用java.io包中的输入输出类就可以达到输入输出信息的目的。Java所有的输入和输出操作都要通过I/O包中的一些流类的方法来实现。
2. 输入输出流可以分为以下几类：
3. (1)从流的方向划分：输入流或输出流；
(2)从流的分工划分：节点流或处理流；
(3)从流的内容划分：面向字符的流或面向字节的流
4. Object：(面向字节的流)InputStream，OutputStream，(面向字符的流)Reader，Writer。
5. 面向字符的流(Reader和Writer)：
(1)字符流的源或目标通常是文本文件；
(2)Reader提供了输入字符的API及部分实现，Writer提供了输出字符的API及其部分实现。
(3)Reader和Writer又分为两大类：一类称为节点流，用来从数据源读入数据或往目的地写出数据；另一类称为处理流，对数据执行某种处理。
(4)Reader：
BufferedReader—LineNumerReader(处理流)
CharArrayReader(节点流)
InputStreamReader(处理流)—FileReader(节点流)
StringReader(节点流)
(5)Writer：
BufferedWriter(处理流)
CharArrayWriter(节点流)
InputStreamWriter(处理流)—FileWriter(节点流)
StringWriter(节点流)
6. 字节流(InputStream和OutputStream)：
(1)对象：数据源或目标中含有非字符数据，绝大多数数据是被存储为二进制文件的。
(2)InputStream：
FileInputStream(节点流)
ByteArrayInputStream(节点流)
StringInputStream(节点流)
ObjectInputStream(处理流)
(3)OutputStream：
FileOutputStream(节点流)
ByteArrayOutputStream(节点流)
ObjectOutputStream(处理流)
7. Java中三个标准输入输出：标准输入System.in，标准输出System.out，标准错误输出System.err。
8. 从键盘读入信息并在显示器上显示(throw IOException)
BufferedReader in=new BufferedReader(new InputStream(System.in));
String s;
While((s=in.readLine()).length()!=0)
System.out.println(s)
9. 在D盘根目录创建文本文件Hello.txt，并往里写入若干行文本。(throw IOException)
String fileName =”D：\\Hello.txt”;
FileWriter writer =new FileWriter(fileName);//创建一个给定文件名的输出对象
writer.writer(“Hello!\n”);//往流里写字符数组
writer.writer(“This is my first text file!\n”);
write.close();//关闭流
(在磁盘上创建一个文本文件并往其中写入字符数据，用FileWriter类)
10. 一个Writer类的流可以实现内部格式到外部格式磁盘格式的转换。
11. 在D盘根目录创建文本文件Hello.txt，并往里写入若干行文本。(用try和catc方法处理I/O异常)
String fileName =”D：\\Hello.txt”;
Try{
FileWriter writer =new FileWriter(fileName,true);//创建一个给定文件名的输出对象
writer.writer(“Hello!\n”);//往流里写字符数组
writer.writer(“This is my first text file!\n”);
write.close();//关闭流
}
catch(IOException iox)
{
System.out.println(“Problem writing”+fileName);
}
12. 用来输出字符流的类：FileWriter和BufferedWriter，但BufferedWriter多提供一个newLine()方法用于换行。
13. 在D盘根目录创建文本文件Hello.txt，并往里写入若干行文本。(throw IOException，使用BufferedWriter来换行)
String fileName =”D：\\Hello.txt”;
BufferedWriter out =new BufferedWriter(new FileWriter(fileName));//创建一个给定文件名的输出对象
writer.writer(“Hello!”);//往流里写字符数组
out.newLine();
writer.writer(“This is my first text file!”);
out.newLine();
write.close();//关闭流
14. 读文本文件
String fileName =”D：/newHello.txt”;
String line;
try{ //创建文件输入流并放入缓冲流当中
BufferedReader in =new BufferedReader(new FileReader(fileName));
Line=in.readLine();//读取一行内容
While(Line!=null)//控制循环条件直到文件终点
{
System.out.println(Line);
Line=in.readLine();
}
in.close();//关闭缓冲流，文件输入流自动也被关闭
}
Catch(IOException){ //如出现I/O异常则进入本块处理
System.out.println(“Problem reading”+fileName);
}
注意：FileReader流对象被创建后，文件“newHello.txt”就被打开了，如果该文件不存在，就会抛出一个IOException。
15. 对应于写文本文件的缓冲器，读文本文件也有缓冲器类BufferedReader，具有readLine()函数，可以对换行符进行鉴别，一行一行地读取输入流中的内容。
16. 判断文本文件结尾的办法：利用Reader类的read()方法返回一个int类型整数，如果读到文件末尾，该方法将返回-1。
Eg：int c;
While((c=in.read())!=-1)
System.out.print((char)c);
17. BufferedReader对象的readLine()方法将从一个面向字符的输入流中读取一行文本，并向其放入字符变量line中。如果输入流中不再有数据，就会返回null。
18. 以下方法的功能是将A.txt文件中的内容拷贝到B.txt文件中去
public void fileCopy(){
BufferedReader Source=new BufferedReader(new FileReader(“A.txt”))；
BufferedWriter Dest=new BufferedReader(new FileWriter(“B.txt”));
String line=Scource .readLine();//从A.txt文件中读一行
while(line!=null){
Dest.write(line);//向B.txt文件中写一行
Dest.newLine();//换行
line=Source.readLine();
}
Source.close();
Dest.close();
}
19. Java.io包中的OutputStream及其子类专门用于写二进制数据。FileOutputStream是其子类，可用于将二进制数据写入文件。
20. 将三个int整数型255，0，-1写入数据文件data1.dat中。
Eg：String fileName =”D：/data1.dat”;
int value0=255,value1=0,value2=-1;
try{
DataOutputStream out =new DataOutputStream(new FileOutputStream(fileName));
out.writeInt(value0);
out.writeInt(value1);
out.writeInt(value2);
}
Catch(IOException){ //如出现I/O异常则进入本块处理
System.out.println(“Problem reading”+fileName);
}
21. 读二进制文件，比较常用的类有FileInputStream，DataInputStream，BufferedInputStream。
22. 读取上面写入的三个整数求和。
Eg：String fileName =”D：/data1.dat”;
int Sum=0;
try{
DataInputStream instr =new DataInputStream(new FileOutputStream(fileName));
Sum+=instr.readInt();
Sum+=instr.readInt();
Sum+=instr.readInt();
System.out.println(“The sum is :”+Sum);
Instr.close();
}
Catch(IOException){ //如出现I/O异常则进入本块处理
System.out.println(“Problem reading”+fileName);
}
23. EOFException是IOException的子类，所以只有文件结束的异常才会被捕获到，但如果没有读到结尾，在读取过程中发生的异常就属于IOException。
24. 用InputStream类读取文本文件并打印在屏幕上。
Eg：FileInputStream s =new FileInputStream(“D:/Hello.txt”);
int c;
while((c=s.read())!=-1)
System.out.write(c);
s.close();
25. File类是IO包中唯一表示磁盘文件信息的对象，它定义了一些与平台无关的方法来操纵文件。
26. GZIPOutputStream和ZipOutputStream可分别把数据压缩成GZIP格式和Zip格式，GZIPInputStream和ZipInputStream可分别压缩成GZIP格式或Zip的数据解压缩恢复成原状。
27. 创建的文本文件“Hello.txt”通过GZIPOutputStream压缩成文件“test.gz”，再通过GZIPInputStream解压缩成“test.gz”文件内容显示出来，并且恢复成“newHello.txt”。(throws IOException)
Eg：FileInputStream in =new FileInputStream(“D:/Hello.txt”);
GZIPInputStream out =new GZIPInputStream(new FileInputStream(“D:/test.gz”);
System.out.println(“Writing compessing file from D:/Hello.txt to D:/test.gz”);
int c;
while((c=in.read())!=-1)
{out.write(c);}//写压缩文件
in.close();
out.close();//从“Hello.txt”读取并压缩写入“test.gz”
System.out.println(“Reading file form D:/test.gz to monitor”);
BufferedReader in2 =new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(“D:/test.gz”);
String s;
while((s=in2.readLine())!=null)
{ System.out.println(s);}//读每一行并显示
in2.close();//显示完毕以后关闭文件
System.out.println(“Writing decompression to D:/newHello.txt”);
GZIPInputStream in3=new GZIPInputStream(new FileInputStream(“D:/newHello.gz”));
FileIOutputStream out2=new FileOutputStream(“D:/newHello.txt”);
while((c=in3.read())!=-1)
{out2.write(c);}//写解压缩文件
in3.close();
out2.close();
28. 按以下要求编写程序，要求从命令行输入若干文件名，将所有文件压缩为“C：/abcabcaa.zip”
(1)指定压缩文件名，套接文件流、缓冲流、压缩流
(2) 对命令行中指定的每个文件进行处理
(3) 以文件名为参数设置ZipEntry对象
(4) 从源文件读出，往压缩文件中写入，然后关闭数据流
(5)解压缩文件
import java.io.*;
import java.util.*;
import java.util.zip.*;
public class ZipOutputStreamTester{
//向控制台抛出异常
public static void mian(String[] args)throws IOEcxeption{
FileOutputStream f=new FileOutputStream(“C：/abcabcaa.zip”);
//指定压缩文件名，套接文件流、缓冲流、压缩流
ZipOutputStream out =new ZipOutputSream(new BufferedOutputStream(f));
for(int i=0;i
System.out.printIn(“Wrinting file”+args[i]);
BufferedInputStream in =new BufferedInputStream(new FileInputStream(args[i]));
out.putZipEntry(new ZipEntry(args[i]));// 以文件名为参数设置ZipEntry对象
int c;
while((c=in.read)!=-1){
out.write(c);// 从源文件读出，往压缩文件中写入，然后关闭数据流
}
in.close();
}
out.close();//关闭输入流
//解压缩文件并显示
System.out.printIn(“Reading file”);
FileInputStream fi=new FileInputStream(“C：/abcabcaa.zip”);
ZipInputStream in2=new ZipInputStream(new BufferedInputStream(fi));
ZipEntry ze;
while((ze=in2.getZipEntry())!=null){//获得入口
System.out.printIn(“Reading file”+ze.getName());//显示文件最初名称
int x;
while((x=in2.read())!=-1){
System.out.write(x);
}
System.out.printIn();
}
in2.close();}
}
29. 要是实现对象的序列化，这个对象所属的类必须实现Serializable接口。
30. Java.io包中提供了专门用于对象信息存储和读取的输入输出流类ObjectInputStream和ObjectOutputStream。但这两个类不会保存和读取对象中的transient和static类型的变量。
31. 创建一个对象输出流：
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(“book.dat”));
向流中写对象：
oos.writeObject(book);
32. Java.io.包提供了RandomAccessFile类用于随机文件的创建和访问。使用这个类可以跳转到文件的任意位置度读写数据。此外，程序也可以更新或删除先前存取的数据，而不用重写整个文件。
第七章
1. Java在数组的声明中并不为数组元素分配内存，因此【】中不需要指明数组中元素的个数，即数组的长度，而且必须经过初始化才可以引用。
2. 用关键字new可以动态分配数组内存空间。
3. 使用运算符new只是为数组本身分配空间，并没有对数组的元素进行初始化，即数组元素都为空。此时不能访问数组的任何元素，必须对数组元素进行初始化后，才能访问，需要经过两步：(1)先给数组分配空间，数组的每个元素只是对象的一个引用。(2)然后给每一个数组元素分配空间，并将其引用赋值给对应的数组元素。
4. 为了能够将类的对象持久化，也就是存储到磁盘，应使其加入串行化协议，实现Serializable接口。
5. 常用的排序算法：选择排序，插入排序，交换排序。
6. 集合框架是为了表示和操作集合而规定的一种统一的标准体系结构，包括三大块内容：对外接口，接口的实现和对集合运行的算法。
7. 接口是表示集合的抽象数据类型，使集合的操作与表示愤慨。Java的集合接口具有层次结构。
8. Collection：Set-SortedSet
List
Map：SortedMap
9. 被组织在以Collection及Map接口为根的层次结构中，称为集合框架。
10. Collection的两个子接口为列表(List)及集合(Set)。
11. Set是一个不含重复元素的集合，是数学中“集合”的抽象。Set接口扩展了Collection，并且禁止重复的元素。
12. 如果两个Set对象包含同样的元素，二者便是相等的。
13. 数组的填充和赋值：
System.arraycopy(i,0,j,0,i.length);
Arrays.fill(i,47);
14. 数组的填充和赋值：
15. Collection接口：声明了一组操作成批对象的抽象方法；实现它的类：abstract Collection。
16. 实现集合(Set)接口的两个主要类是哈希集合(HashSet)及树集合(TreeSet)。
17. 实现接口List的类中的元素是有元素的，可以包含重复元素，且每个元素都有一个index值标明元素在列表中的位置。
18. Map是一个从关键字到值的映射对象，Map中不能有重复的关键字，每个关键字最多能够映射到一个值。
19. List接口在声明时可以带有两个参数，即Map，其中K表示关键字的类型，V表示值的类型。
20. SortedSet，升序排列，通常用于存放词汇表。
21. 算法Shuffle的作用与排序算法恰好相反
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
