Java基础学习笔记（完整版）

github：https://github.com/xierongwkhd/JVNOTE
目前情况
暂定学习路线：
基础√-接口√-常用类√-GUI√-异常处理√-集合框架√-IO流√-反射√-网络编程√-JavaWeb-…
最近在做一个简单的人事管理系统（swing + 一点mysql）

注：上面说的练习小项目写完了，在我的github上，希望大家一起学习交流

---

基础

1.HelloWorld

public class HelloWorld{
	
	public static void main(String[] args){
		
		System.out.println("Hello World!");//ln换行->println换行输出
	}
}

CMD编译：javac xxx.java->xxx.class(字节码文件)【C/C++编译后为可执行文件】
运行：java HelloWorld(xxx)
字节码：一套在JVM中执行的高度优化的指令集->可移植性

2.Java基本元素：
空白分隔符->空格，tab键，换行符
关键字（50）->访问控制

	private protecred public

类，方法和变量修饰符

	abstract class extends final implements interface
	native new static strictfp synchronized transient volatile

程序控制

	break continue return do while if else for instanceof switch case default

错误处理

	try catch throw throws

包相关

	imprt package

基本类型

	boolean byte double float int long short
	(null true false不是关键字，是单独的标识类型)

变量引用

	super this void

保留字

	goto const

标识符->类，方法，变量的名字
注释-> 单行：//xxx 注释块： /* xxx / 文档注释： /* xxx */
分隔符
()圆括号 定义方法的参数表。定义表达式的优先级。
{}花括号 初始化数组，定义程序块，类，方法。
[]方括号 声明数组类型。
; 分号 表示一个语句的结束。
, 逗号 变量声明时用于分隔多个变量。
. 点 用于软件包和子包或类，对象和变量或方法分隔。

3.Eclipse
src：存放源文件
bin：存放编译后的字节码文件
.classpath .project:项目配置文件

4.八大数据类型
整形：byte short int long
字符型：char（Unicode）
浮点型：float(单精度 4字节) double(双精度 8字节)
布尔型：boolean(ture/false)
定义常量关键字：final（习惯上常量用大写）

5.数据类型转换
自动转换：条件->目的类型比原来的类型要大
两种类型是相互兼容的
byte->short
short->int
char->int
int->long
int->double
float->double
强制类型转换：double a=3.55555
int b=(int) a
b=3

6.赋值float类型 float xxx->xxx=3094.5F
局部变量->必须手动进行初始化
类变量（static）、实例变量->编译器自动初始化

10.字符串
字符串变量：String类（String xxx=“Hello World!” System.out.println(xxx)）>存在常量池
字符串的连接： 字符串1 + 字符串2（用+连接两个字符串）
①Sysytem.out.println(“xxx1”+“xxx2”)
②String xxx3=xxx1+xxx2 （String xxx3=" “+xxx1+”\n"+xxx2）
看字符串长度：System.out.println(xxx.length())
转义字符：\n \t \r

字符串处理：
①求子串String xxx1=" "->xxx2=xxx1.substring( , )【前闭后开】
②测试字符串是否相等

Object equals：比较内存地址（相当于等号==）s1==s2
String equals：比较内容  s1.equals（s2）
String a="xxx"; String b="xxx";  a==b(都在常量池里面，同一内存地址)
String c=new String("xxx") 
（new出来的都在堆内存，且都是【新】对象，有不同的堆内存地址）

③字符串编辑->字符串内容不可变，改变的是引用
④字符串其他操作：查看API

11.运算符
基本算术运算符、自增自减运算符 # i++先用后加 ++i先加后用
模运算符-> %求两个整数相除的余数 #包含浮点类型取模不准确，精度高的类型用BigDecimal类型
关系运算符(== != > < )、逻辑运算符(&逻辑与 |逻辑或 !逻辑非 &&短路与 ||短路或)
三元运算符： (条件)?(符合):(不符合)
运算符优先级 #()优先级最高

12.流程控制

switch(表达式){
    case value1:
	break;
    case value2:
	break;
    default:
}//value值和表达式类型一致

循环结构：while/for for(初始化;条件;迭代运算){循环语句;}
break：强制当前循环终止
continue：停止本次循环，继续执行剩下的循环
return：从当前的方法中推出。执行后，方法内剩余的代码都不会执行

12.数组 //一组相同类型的数的集合
创建数组： ①//声明数组
a.类型 数组名 [];-------- double array1[length]
b.类型[] 数组名;--------- String[] array2,array3 （常用）

array1=new double[5];
array1[0]=1;//数组元素赋值

初始化数组： ①元素一个个赋值
②int[] array1={1,2,3,4};
③多维数组运用多重循环对数组进行赋值

获取数组长度：system.out.println(array1.length);
#创建一个Scanner类的对象，用它来获得用户的输入

import java.util.Scanner;				//使用Scanner之前先导包
Scanner sc=new Scanner(System.in);			//创建
for(student=0;student<temp.length;student++){
temp[student]=sc.nextDouble();			//输入
sum+=temp[student];
}

数组的复制：通过赋值操作（array1=array2），两个引用指向同一个数组（地址）
多维数组：
*Java中只存在一维数组，多维数组则是数组中的数组（数组中的元素存放另一数组）

int[][] n=new int[5][5];
int[][] n1={
{1,2,3,9}
{4,5,6,9}
{7,8,9,9}	
};
不规则数组：数组的各个元素存放不同长度的数组

13.类的一般形式
类：事物的集合和抽象。代表这类事物所共有的一些行为和属性
class 类名{ //类
类型 变量名; //属性
类型 方法名（参数）{ //方法
方法内容
}
···
}
修饰符：private-----------只有在本类中可以看见
protected---------在本类或者是同一个包里面可见
public------------对于所有类都可见
默认（无修饰符）–在本类或者是一个包里面可见//有别于protected
父类=超类=基类、子类=派生类

14.方法
无返回值，定义必须写void
有返回值，则定义的方法类型必须和方法体内返回值的类型相同
例： public String returnString(){
return “返回值是字符串类型”; }
主方法：程序的入口。public static void ain(String[] args){ }
构造方法：
用于初始化参数。所有的数字变量全部设置为0。所有的boolean类型全部设置为false
所有的对象类型赋值为null。
People p=new People(); //People()->构造方法，编译器自动初始化People类内的变量
也可以自定义构造方法（People()）没有返回值,且编译器不提供默认的构造方法（自写）
有参的构造方法：

 People(String name,String sex,int age){
	this.name=name;
	this.sex=sex;
	this.age=age;		//this:当前类
 }
 People p=new People(" "," ", );

方法的重载：
具有相同的方法名称，但具有不同的参数列表（参数的数量、类型、次序等）
构造方法重载：//简化->this(name,age); //调用本类中其他构造器

	 super();//调用副类构造器（object类）	

15.对象（类的实例）

       com=new Computer();
       即Computer com=new Computer();

对象类型的参数传递：引用类型的传递
基本数据类型作为参数直接操作，引用类型作为参数，操作的是引用指向的堆内存中的对象

Animal a= new Animal();
prinftAnimal(a);//声明的prinftAnimal(Animal a)函数

16.关键字
static：静态变量->属于类的变量//可以直接访问 类名.变量名
静态方法->用static修饰的方法，访问同静态变量，不能访问非静态变量//非静态方法可以访问静态变量
静态常量-> public static final int x=1;
final：
①修饰恒定不变的变量（不可改变且大写）
②修饰方法->任何继承类无法重写覆盖该方法，但可以重载 #继承class xxx extends xxx
③修饰类->该类不能作为任何类的父类，且类中的方法全被定义为final类型

包：命名包/未命名包（一般不用）

17.三大特性封装、继承、多态
封装：通过private对信息进行封装，通过setXXX()方法进行访问
//方法中可以加入条件，即对用户开放的信息进行限制

继承：class xxx1 extends xxx2 //extends只能继承一个类，JAVA不支持多重继承
在xxx1中可以调用父类的方法，可以重写继承类（父类）xxx2中的方法，也可以增加自己的方法
子类继承父类，编译器默认加上 super(); 调用父类的无参构造器（先父类再子类）
#调用有参构造方法必须自己加 super（参数）;
#super();必须放在方法第一个语句中

		       Tiger a=new Tiger()----Animal a=new Tiger()

18.抽象类->为子类提供一个规范（子类可定义不同的方法体）
public abstract class 类名{类体};/抽象类，抽象类中至少有一个抽象方法（可以有普通方法）
public abstract void test();//抽象方法没有方法体，即规范（由继承的子类定义方法）
应用：
@Override//检测是否重写成功
一个类继承了抽象类，就必须重写抽象类中的所有抽象方法（如果为抽象类继承抽象类则不用）
#Animal instanceof mouse 判断该继承Animal的类是否为mouse类（instanceof）

19.内部类：一个类被嵌套定义在另一个类中，即为内部类，包含内部类的类为外部类
内部类相当于外部类的成员变量
Outer out=new Outer();//先构造外部类
Outer.Iner in=out.new Inner();//才能构造内部类
匿名内部类：实现类的时候没有名字**************继承父类并重写方法，即为子类
局部内部类：在方法等局部位置的类，局部内部类可以访问局部（方法中）的final类型的变量和外部类所有成员变量【为什么只能访问final类？？？】
静态内部类：内部类有static修饰符的内部类，
内部可以声明static成员变量（非静态内部类不可以）
不可使用外部类的非静态成员变量
创建对象时，不需要其外部类的对象#StaticInner.Inner i=new StaticInner.Inner
??为什么内部类可以使用外部类的成员变量？？
引用外部类的对象：内部类：this.count 外部类：Outer.this.count
内部类的继承：

   public class Test extends A.B{
		public Test(A a){
		a.super();   }         } //先对外部类进行实例化

---

设计模式

15*.设计模式
设计模式：解决某一种问题的一种优化的思想，是一种行之有效的解决方式//总共有23钟模式

单例设计模式：
解决的问题->保证一个类的对象在内存中的唯一性
应用场景->多个程序都在操作同一个配置文件时，需要程序A操作后的结果，程序B要知道并继续基于A操作后的结果进行操作
    //前提：数据都存储在配置文件对象中，要求程序A和程序B操作的配置文件对象时同一个

	/*饿汉模式*/
 class Single{
 	private static final Single s= new Single();//创建本类对象
 	private Single(){}//构造函数私有化,使外部无法通过new创建其对象
 	public static Single getInstance(){//定义一个返回该对象的方法，使程序可以获取(为了可控)
 		return s;
 	}
 }
 /*另一种形式，延迟加载方式（懒汉模式）*/
 class Single{
 	private static final Single s= null;//创建本类对象
 	private Single(){}//构造函数私有化,使外部无法通过new创建其对象
 	public static Single getInstance(){//定义一个返回该对象的方法，使程序可以获取(为了可控)
 		if(s==null)
 			s = new Single();
 		return s;
 	}
 }

---

接口

20.接口（完全抽象，里面只能有抽象方法和常量）
interface 定义接口的修饰符（interface xxx）只能被默认或public修饰
int i=1------>public static final int i=1(变量会被设置成公有的静态的常量)
方法的修饰符->public abstract即抽象修饰符
实现：class 类名 implemets 接口1,接口2,接口3{ 方法 };//区别于extends，
#如果这几个接口都有相同的方法和变量，那么通过 接口名.变量名 的形式访问
相同的方法将被其中的一个接口使用（只重写一次）
注1.实现的子类为接口中所有的方法具体实现
2.重写时：
①子类的重写方法不能抛出更大的异常*
②子类的重写方法不能有更小的访问范围，即public->protect
3.保持相同的返回类型
*接口类型引用调用test2 t=new test2(); Jia mJia=t;//从对象t中
通过创建mJia接口调用Jia方法

---

常用类

21.常用类(对象API)
Object类：子类初始化构造（super()）->父类
父类初始化->Object//所有类的根类，具备所有对象都具备的共性内容
#常用共性方法：①equals()两种对象我是否相等 //p1.equals(p2) ->比较地址<-
**equals()一般都会覆盖上述方法，根据对象的特有内容，建立判断对象是否相同的依据
（自0己建立比较形式）
②hashCode()->重写equals()时需要重写此方法，相等对象必须具备相等的哈希码
③getclass()->获取当前对象的字节码文件对象Person.class
Class class1 = p.getClass();
④toString()->getClass().getName()+"@"+Integer.toHexString(p.hashCode())
//通常重写

String类：
①字符串对象一旦被初始化就不会改变，储存在字符串常量池中//s1=xxx;s2=xxx->s1 == s2
②String s = “abc”–String s1 = new String(“abc”)->s与s1不同地址，""可以共享，new在堆内存（特点）
③字符串对象中用equals()比较的是内容
④构造函数（API）
常见功能：
1.获取->获取字符串的长度

int length();

根据位置获取字符

char charAt(int index)

根据字符获取字符串中的位置

int indexof(int ch)   
int indexof(int ch,int fromIndex)//从指定位置进行ch查找
int indexof(String atr)·····//API中查看

2.转换->将字符串变成字符串数组

String[] split(String regex)//正则表达式

将字符串变成字符 数组

char[] toCharArray()

将字符串变成字节 数组

byte[] bytes getBytes()//s = " "

将字符串这种的内容替换

replace(char oldchar,char newchar)

将字符串两端的空格去除

String trim()//连接String concat(string)->同+

3.比较->compareTo---------------intern方法
判断字符串是否相同：
 boolean equals(Object obj);
 boolean equlasIgnoreCase(String str);//忽略大小写比较字符串内容

判断字符串是否包含：
 boolean contains(String str);

判断字符串是否以指定字符串开头或结尾：
 boolean startsWith(String str);
 boolean endsWith(String str);

#SringBuffer类#：字符串缓冲区，用于存储数据的容器
特点： ①长度可变（初始为16个字符，不够则自动增加，可以通过构造器自定义初始化长度）
   ②可以存储不同类型数据
   ③添加到对象中都转成字符串
   ④可以对字符串进行修改

常用功能：
 添加：append(data);//data->除了byte和short的其他数据类型

 StringBuffer sb = new StringBuffer();//创建缓冲区对象
 sb.append(4).append(false).apend("haha");//append返回的还是StringBuffer对象

 插入：insert(index,data);
 删除：StringBuffer delete(start,end);//包含头，不包含尾 0-length
    StringBuffer deleteCharAt(int index);
 查找：char charAt(index);
    int indexOf(String);
    int lastIndexOf(String);
 修改：StringBuffer replace(start,end,String);
    void setCharAt(index,char);
其他方法：
 setLength(len);设置缓冲区的大小
 reverse();//y数据反转（首位对调）

#SringBuilder类#：与StringBuffer作用相同，但是线程是不同步的，速度更快，主要用于单线程

#System类#：不能被实例化，都是静态方法
System.err;//字段摘要，“标准”错误输出流
System.out;//返回的是PrintStream对象，所以可以调用其方法->System.out.println();
System.in;//InputStream

常见方法：
 long currentTimeMillis();//返回以毫秒为单位的当前时间，常用于计算程序或方法执行时间
 getProperties();//获取系统所有的属性信息（getPorperty(String):通过指定的键获取系统信息），并以Properties集合（详见IO流）返回

 Properties prop = System.getProperties();
 Set<String> nameSet = prop.stringPropertyName();
 for(String value : nameset){
 	String value = prop.getProperty(name);
 	System.out.println(name+"::"+value);
 }

 line.separator;//系统行分隔符，适用于任何系统

 System.out.println("hello"+System.getProperty("line.separator")+"world");
 private final static String line_separator =  System.getProperty("line.separator");//通常用法，在使用时调用

 setProperty(String str1,String str2);//给系统设置一些属性信息，其它程序都可以使用

#Runtime类#：没有构造方法，该类不能实例化，且有非静态方法，则说明提供了返回该类对象的静态方法(单例设计模式)

 Runtime r = Runtime.getRuntime();//获得程序中的Runtime对象
 Process p = r.exec("notepad.exe c:\\abc.java");//可以开启硬盘上的执行文件并解析abc.java文件（有IO异常），返回一个进程
 p.destroy();//只能摧毁Runtime对象创建的线程

#Math类#：提供了操作数学运算的方法，都是静态的
常用方法：
 double cell(double);//返回大于参数的最小整数
 double floor(double);//返回小于参数的最大整数
 double round(double);//返回四舍五入的整数
 int max(int a, int b);//取最大，可以是其它数据类型
 pow(a,b);//a的b次方
 double random();//返回带正号的double，该值大于等于0.0且小于1.0（伪随机）
同时还有随机数对象：Random r = new Random();

#Data类#：日期对象
构造方法： Data();和Data(long time);//time为某一时间的毫秒值（可以由System类获得）
日期对象和毫秒值之间的转换：

 //毫秒值->日期对象（可以对日期的年月日秒等字段进行操作）
 new Data(timeMillis);
 setTime();
 //日期对象->毫秒值（可以通过具体数值进行运算）
 getTime();

对日期对象进行格式化：DataFormat类

 Date date = new Date();
 DateFormat dateFormat = DateFormat.getDateInstance();//2018-10-15->MEDIUM（默认风格）
 dateFormat = DateFormat.getDateTimeInstance();2018-10-15 14:17:30
 dateFormat = DateFormat.getDateTimeInstance(DataFormat.LONG,DataFormat.LONG);//分别指定日期和时间的风格
 dateFormat = DateFormat.getDateInstance(DataFormat.LONG);//2018年10月15号
 dateFormat = DateFormat.getDateInstance(DataFormat.FULL);//2018年10月15号 星期一
 dateFormat = DateFormat.getDateInstance(DataFormat.short);//18-10-15
 /*自定义风格：用到DataFormat的子类 SimpleDateFormat*/
 dateFormat = new SimpleDateFormat("yyyy--MM--dd");//2018--10--15
 
 String str_date = dateFormat.format(date);//将日期对象转换成日期格式的字符串
 /*将日期格式的字符串转换成日期对象*/
 String str = "2018-10-15";
 DataFormat dateFormat = DataFormat.getDateInstance();//根据字符串的风格来定义
 Date date = dateFormat.parse(str);

操作日历字段提供方法：Calendar类

 Calendar c = Calendar.getInstance();
 int year = c.get(Calendar.YEAR);//MONTH（从零开始）,DAY_OF_MONTH,DAY_OF-WEEK等同理，为键值对的形式
 c.set(2018,10,15);//设置时间，不设置则默认为系统时间
 c.add(Calendar.YEAR,2);//在原本的年份上加两年

---

异常

22.异常：运行时期发生的不正常情况
处理异常方式：用类的形式对不正常情况进行描述和封装对象，描述不正常情况的类则称为异常类,不同的问题用不同的异常类进行具体描述（描述的类很多，将其共性向上提取，形成体系即继承，父类Throwable）

对异常进行捕捉或声明，使其抛出
所有类分成两大类：Error类（不可处理），Exception（可处理）
抛出异常：前提–Throwable父类下的子类都可抛且应该抛出
凡是可以被throws，throw关键字操作的类和对象都具有可抛性
#数组角标越界throw new ArrayIndexOutOfBoundsException(index)//默认抛出
自己定义

throw new ArrayIndexOutOfBoundsException(" "+index)

已存在异常直接抛出，如

throw new ArrayIndexOutOfBoundsException

自定义异常：

class FuShuIndex extends Exception

声明： 抛出异常时，必须先声明【定义处理的方法或调用的方法都得声明throws FuShuIndex】
throw抛出异常对象，throws抛出异常类【可抛出多个】
throw new FuShuIndex(" "+index)->自定义异常类中创建构造方法（参数为String类）
并super();//调用父类构造器

    class FuShuIndex extends Exception
    {
	FuShuIndex(){};
	FuShuIndex(String mag){ super();}
     }

★编译时不检测异常（运行时异常）：Exception中的RuntimeException和其子类
自定义异常时继承Exception或RuntimeException
捕捉：对异常进行针对性处理（自己能处理的异常）
格式：

 try
		 {  //需要被检测异常的代码
		  }
		 catch(异常类 变量)//该变量用于接收发生的异常对象，异常类为throws出的类
		 {  //处理异常的代码
		  }
		 finally
		 {  //一定会被执行的代码*
		  }

??对象当作字符串打印 对象.toString()
多catch情况->throws几个异常就用多少catch进行捕捉处理
#catch(Exception e)–>处理未知异常
多catch时父类的catch放在最后

异常处理原则：
1.函数内部如果抛出需要检测的异常，那么函数上必须要声明。
否则必须在函数内用trycatch捕捉，否则编译失败。
2.如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败
3.什么时候catch，什么时候trows？
功能内部可以解决，用catch
解决不了，用throws告诉调用者，由调用者解决
4.一个功能如果抛出多个异常，那么调用时，必须有多个catch进行针对性处理
finally代码块：连接数据库-查询-关闭连接->通常用于关闭（释放）资源
//退出虚拟机 System.exit(0)
*特点：组合try catch finally
try finally->异常无法直接catch处理，但是资源需要关闭
异常转换：catch一个异常抛另一个异常//异常的封装

在数据库中的应用：

 void addData(Data d)throws SQLexception
		{
			连接数据库
			try
			{
			添加数据//出现异常 SQLExcption();
			}
			catch(SQLException e)
			{}
			关闭数据库
		}

异常注意事项：
1.子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的
异常或该异常的子类。
2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集
//如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，只能try

---

正则表达式

23.正则表达式//用于操作字符串数据【特定的符号来体现】
①定义正则表达式规则：String regex = “[1-9][0-9]{4,14}”;//正则表达式:第一个数1-9，4-14位数0-9
②boolean b = qq.matches(regex);//验证字符串qq是否符合规则：matches(regex)
※各种符号意义（API）
正则表达式对字符串的常见操作：
1.匹配->

		   matches方法   /*   "1[359]\\d{9}"   */

2.切割->

		   splift方法    split(String regex)   //组：((A)(B(C)))

3.替换->

           replaceALL()方法    replaceALL(String1,String2)

4.获取->

		  Patern p = Pattern.compile("a*b");//将正则规则进行对象的封装
		  Matcher m = p.matcher("aaaaab");
		  //通过正则对象的matcher方法字符串相关联。
		  获取对字符串操作的匹配器对象Matcher
		  boolean b = m.matcher();//通过Matcher匹配器对象的方法对字符串进行操作 

---

集合

24.集合
1.存放多个对象（封装特有数据）的容器
2.集合可变长度即存放的对象个数不确定//区别于数组
3.不能存储基本数据类型值（数组）

集合容器因为内部数据结构的不同，有多种具体容器，不断的向上抽取，就形成了集合框架
框架的顶层为：Collection接口(根接口)//使用时要导包import
其常见方法：

	 添加 boolean add(Object obj);
	     boolean addAll(Collection coll);
	 删除 remove(Object obj);//改变集合长度（删除元素，返回boolean）
	     removeAll(Collection coll);
	     //c1.removeAll(c2)将c1,c2集合中相同元素从c1集合中删除
	     void clear();//清空集合
	 判断 boolean contains(Object obj);//是否在obj中存在相同元素
	     boolean containsAll(Collection coll);
	     boolean isEmpty();//判断是否为空
	 获取 int size();
		 Iterator iterator();//迭代器：取出元素（Collection子接口的对象通用）
	 其他 boolean retainALL(Collection coll);//取交集
	      Object[] toArray{};//将集合转成数组
	 等共性方法API  ##必须掌握##

迭代器的使用：

   Collection coll = new ArrayList();
   coll.add("abc1");
   coll.add("abc2");
   coll.add("abc3");
   Iterator it = coll.iterator();//获取集合中的迭代器对象
   System.out.println(it.next());//abc1
   System.out.println(it.next());//abc2------->next() /* 区别于直接print coll */
  /*while(it.hasNext()){
	System.out.println(it.next());
     }//abc1
	abc2------>hasNext() */ 取出元素后，无法在用next()取出 */

（基本原理）：
取出元素的方法封装成对象（即iterator），通过此对象中的方法（next(),hasNext()）对元素进行操作
//迭代器对象是在容器中进行内部实现的Collectiuon下的子接口：List,Set//常用，也可以自己定义链表等各种数据结构
①List：有序（存入和取出的顺序一致），元素都有索引（角标），元素可以重复
②Set：元素不能重复，无序。
List特有的常见方法（特点是可以操作角标）:

void add(index,element);
void add(index,collection);//添加
Object remove(index);//删除
Object set(index,element);//修改
Object get(index);//获取
listIterator(); ListIterator it = list.listIterator()-->获取列表迭代器对象

//在迭代过程中不能使用集合操作，此时使用Iterator的子接口ListYterator来操作迭代元素
List集合常用对象：
①Vector:内部是数组数据结构。是同步的。 //特有方法：带有elements字样的方法
Vector中的枚举elements()方法（接口：Enumeration）,与迭代器（接口：Iterator）功能重复
②ArrayList：内部是数组数据结构。是不同步的。–>替代Vector//查询速度快
ArrayList存自定义对象( add(new 对象) )时，迭代器it.next()需要转化----(person)it.next()
//初始容量为10，****拆箱装箱
③LinkedList：内部是链表数据结构。是不同步的。//增删元素的速度很快
数据结构：a.堆栈（先进后出），b.队列（先进先出）
//用LinkedList中的方法可以实现这两种数据结构，即构建一个相同功能的容器

addFirst() addLast() removeFirst() removeLast()
getFirst()-----如果链表为空，则抛出异常//区别于peekFirst()---如果链表为空，则返回null
offerFirst(),pollFirst()

Set集合(不包含重复元素，无序)：
接口中的方法和Collection一致//重复编译无错，取出时只有一个
常用对象：
①HashSet：内部数据结构是哈希表，是不同步的
=>哈希算法–哈希值-（哈希表）-作为元素的引用（查询快//通过算法可以直接得到位置）
HashCode方法↑ //元素的哈希值相同，则 才会 继续判断内容（equals()）
存储自定义对象时，需要自定义（重写）HashCode方法和equals方法：

			public int hashCode(){
   
				return name.hashCode()+age*37;//调用String类型的name的哈希hashCode方法
				}
			public boolean equals（Object obj）{
   
				if(this == obj)
					return ture;
				if(!(obj instanceof Person))
					throw new ClassCastException("类型错误")
				person p =(person)obj;
					return this.name.equals.(p.name)&&this.age == p.age;
				}

****ArrayList: 使用equals（contains/remove）判断元素是否相同
HashCode: 使用hashCode+equals来判断
②TreeSet(数据结构：二叉树):可以对Set集合中的元素进行排序
// 判断元素唯一性的方法，根据比较方法的返回结果是否是零，是零则相同，不是则不同
=>排序方法（一）【对象默认排序方式】
让元素自身具备比较功能，就必须实现Comparable接口(implements Comparable)，
重写int comparableTo(Object o)方法

*如果不要按照对象中具备的自然排序（返回1，-1，0）进行排序。如果对象中不具备自然顺序
=>排序方法（二）【比较器】
让集合自身具备比较功能，定义类 实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数

	TreeSet test = new TreeSet(new  定义的类名());

**Map集合(**接口):
区别于Collection->

1. Map一次添加一对元素（双列集合），Collection（单列集合）
2. 集合中必须保证键的唯一性
   其常见方法：

		添加 	value put(key,value)
			  //返回前一个和key关联的值，如果没有返回null
			  相同键（key），值（value）会覆盖
		删除 	void clear()//清空
			  value remove(key)//根据指定key删除这个键值对
		判断 	  boolean contains(key);//是否包含
	（和CL一样）	boolean containsAll(value);	
				boolean isEmpty();//判断是否为空
		获取	  value get(key)//通过键值获取，如果没有该键返回空
				int size();//键值对个数

*取出map所有元素的方法//区别于Collection
第一种：
①通过keySet方法获取map中所有的键所在的Set集合
②通过Set的迭代器获取到每一个键
③再对每一个键通过map集合的get方法获取其对应的值

例：	Map<Integer,String> map
		map.put(......)....
		Set<Integer> keySet = map.keySet();
		Iterator<Integer> it = keySet.iterator();
		while(it.hasNext()){
   
			Integer key = it.next();
			String value = map.get(key);
			System.out.println(key);
		}

第二种：
entrySet方法//将Map转换为Set进行迭代，将键和值的映射关系作为对象存储到Set集合中

 例：	Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
		Iterator<Map.Entry<Integer,String>> it = entrySet.iterator();
		//Entry：Map接口的内部接口（内部嵌套类），键和值的关系对象
		while(it.hasNext()){
   
			Map.Entry<Integer,String> me = it.next();
			Integer key = me.getKey();
			String value = me.getValue();//Map.Entry对象的方法
			System.out.println(key);
		}

第三种(只取值)：Map的values()方法

例：	  Collection<String> values = map.values();//对values进行迭代
		  Iterator<String> it = values.iterator();

常用子类对象：
①Hashtable（哈希表，同步//不允许nulll作为键或值）
------Properties：用来存储键值对型的配置文件的信息//IO
②HashMap（哈希表，不同步//允许nulll作为键或值）—>HashSet是HashMap的实例

HashMap<Student,String> hm = HashMap<Student,String>();
/*存储自定义对象时和HashSet一样，在自定义对象的类中重写HashCode和equles方法
 *取出方法同取出Map元素
 *LinkedHashMap//存和取的顺序是一样的
*/

③TreeMap（二叉树，不同步//对Map中的键进行排序）

---

泛型

**（安全机制）
用于接收具体引用数据类型的参数范围
优点：
1.将运行时期的ClassCastException转到了编译时期---->用于编译时期，确保了类型的安全
2.避免了强制转换的麻烦

ArrayList<String> test = new ArrayList<String>;
//规定ArrayList集合中元素的类型为String

注：
擦除->运行时会将泛型去掉，既生成的class文件中不带泛型，称为泛型的擦除//为了兼容运行的类加载器
补偿->在运行时，通过获取元素的类型进行转换动作，不用使用者再进行强制转换
*TreeSet设置泛型时，注意实现比较接口时，指定比较类型

		implements Comparable<Person>//比较的是Person类
并重写： int comparableTo(Person p)//第二种排序的方法同理

自定义泛型类：
当类中的操作的引用数据类型不确定的时候，就使用泛型类表示

	 class tool<test> {
   }->tool<String> tl = new tool<String>();

泛型方法：

     public <test> void show(test test1){
   }
     //在有具体数据类型的泛型类中，方法可以操作其他数据类型

*当方法静态时，不能访问类上定义的泛型，只能将泛型定义在方法上
泛型接口：

                interface Inter<T>{
   
				public void test(T t);
			  }//可以在定义实现接口的类时指定数据类型，也可以在创建对象时再明确数据类型

泛型的通配符： ？ //未知类型

	例：	public static void printCollection(Collection<?> a){
   
					Iterator<?> it = a.iterator();					
					while(it.hasNext()){
   
					System.out.println(it.next());
					}
				}//迭代并打印任意类型集合的任意类型的元素

泛型对类型的限定：

	 上限：?  extends E  
	  例	  Collection<? extends person>
		  //只能传person或者person子类的对象

体现–> 一般在存储元素的时候都是用上限，因为取出时都是按照上限类型(person)来运算的，不会出现类型安全隐患

	下限：？ super E    //接收E类型或者E的父类型的对象

体现–> 通常对集合中的元素进行取出操作时，可以是用下限

---

IO流

23.IO流（Input Output）
用于操作流的对象：IO包
流按操作数据分为：字节流 字符流//字符流->字节流读取文字字节数据后，查找指定编码表获取对应文字，在对文字进行操作
流按数据流向分为：输入流 输出流（相对于内存 读 写）
一个流关联一个文件

子类都以父类名作为后缀，而子类名的前缀就是该对象的功能
字节流的抽象基类：
· InputStream  · OutputStream
字符流的抽象基类（操作文字数据）：
·Reader  ·Writer

①字符流例：
FileReader:

	/*FileReader->输入流对象，读取字符文件到内存，显示到控制台
	 *创建对象是，必须明确读取的文件且是存在的
	*/
	FileReader fr = new FileReader("demo.txt");//demo.txt中为"ab"
	
	/*第一种读取方式 read()*/
	int ch = fr.read();//用read()方法读取字符,返回int类型
	System.out.println(ch);//显示97->a
	int ch1 = fr.read();
	System.out.println(ch1);//显示98->b
	int ch2 = fr.read();
	S