JavaSE学习经验整理

JavaSE学习经验整理

前言
这是本博主对JavaSE的个人认知和心得与各位IT伙伴分享，也是我入CSDN大家庭以来的首次写微博目的就是想与大家交流并分享。
首先本人也是个刚入行一年的IT小白，在大学时期查资料的时候偶然进入csdn网站之后给我的感觉是打开了一扇窗。让我不再是面向百度编程。总之是程序猿(媛)的一块乐土吧。
闲话不说上图镇楼开始我的总结！！！

首先为了新手小白准备了些常用的快捷键知识点

键盘功能键的认识和快捷键
(1)功能键
tab、shift、ctrl、alt、windos、空格、上下左右、回车、截图
(2)快捷键
全选 ：Ctrl+A、复制：Ctrl+C、粘贴：Ctrl+V、剪切：Ctrl+X、撤销：Ctrl+Z、保存：Ctrl+S
(3)实用操作键
打开我的电脑：win+e、显示桌面：win+d
常见的DOS命令操作
(1)常见的如下
盘符的切换: d:回车
目录的进入: cd javase
cd javase\helloworld
目录的回退: cd… cd
清屏: cls
退出: exit

Java语言概述

Java语言的特点:
有很多小特点，重点有两个开源，跨平台
Java语言的平台：
JavaSE、JavaME–Android、JavaEE
JDK,JRE,JVM的作用及关系：
(1)作用
JVM：保证Java语言跨平台
JRE：Java程序的运行环境
JDK：Java程序的开发环境
(2)关系
JDK：JRE+工具
JRE：JVM+类库
path环境变量

(1)path环境变量的作用
	保证javac命令可以在任意目录下运行。
(2)path配置方案：
		找到环境变量的位置，在系统变量里面
		新建：
			变量名：JAVA_HOME
			变量值：D:\develop\Java\jdk版本(建议使用JDK5或JDK8)
		修改：
			变量名：Path
			变量值：%JAVA_HOME%\bin;以前的内容

classpath环境变量

(1)classpath环境变量的作用
	保证class文件可以在任意目录下运行
(2)classpath环境变量的配置
	找到环境变量的位置，在系统变量里面
	新建：
		变量名：classpath
		变量值：E:\JavaSE\HelloWorld

入门程序：HelloWorld案例

class HelloWorld {
		public static void main(String[] args) {
			System.out.println("HelloWorld");
		}
	}

(1)程序解释：
	A:Java程序的最基本单位是类，所以我们要定义一个类。
		格式：class 类名
		举例：class HelloWorld
	B:在类中写内容的时候，用大括号括起来。
	C:Java程序要想执行，必须有main方法。
		格式：public static void main(String[] args)
	D:要指向那些东西用大括号括起来。
	E:简单的输出
		格式：System.out.println("HelloWorld");
		""里面的内容是可以改动的。

(2)Java程序的**加粗样式**开发执行流程：
	A:编写java源程序(.java)
	B:通过javac命令编译生成.class文件
	C:通过java命令运行.class文件

书写规范(公司很在意书写规范，没有规则不成方圆)

1:关键字

(1)被Java语言赋予特定含义的单词
(2)特点：
	全部小写。
(3)注意事项：
	A:goto和const作为保留字存在。
	B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记

2:标识符

(1)对类，接口，方法，变量等起名字的字符序列
(2)组成规则：
	A:英文大小写字母
	B:数字
	C:$和_
(3)注意事项：
	A:不能以数字开头
	B:不能是java中的关键字
	C:区分大小写
(4)常见的命名规则(根据你起的名称了解它的含义)
	A:包	全部小写
		单级包：小写
			举例：dexi,com
		多级包：小写，并用.隔开
			举例：cn.dexi,com.baidu				
	B:类或者接口
		一个单词：首字母大写
			举例：Test,Demo
		多个单词：每个单词首字母大写(驼峰式)
			举例：HelloWorld
	C:方法或者变量
		一个单词：首字母小写
			举例：main
		多个单词：从第二个单词开始，每个单词首字母大写
			举例：studentName,showAllNames()
	D:常量
		全部大写
		一个单词：大写
			举例：A
		多个单词：大写，并用_隔开
			举例：STUDENT_MAX_AGE

3:注释

(1)对你写的程序进行解释说明的文字(非常有必要，对你和别人都很负责)
(2)分类：
	A:单行注释	//
	B:多行注释	/**/
	C:文档注释(后面讲) /** */
(3)注释的作用
	A:解释说明程序，提高了代码的阅读性。
	B:可以帮助我们调试程序。

4:常量

(1)程序执行的过程中，其值不发生改变的量
(2)分类：
	A:字面值常量
	B:自定义常量(后面讲)
(3)字面值常量
	A:字符串常量 "hello"
	B:整数常量	12,23
	C:小数常量	12.345
	D:字符常量	'a','A','0'
	E:布尔常量	true,false
	F:空常量	null
(4)在Java中针对整数常量提供了四种表现形式
	A:二进制	由0，1组成。以0b开头。
	B:八进制	由0，1，...7组成。以0开头。
	C:十进制	由0，1，...9组成。整数默认是十进制。
	D:十六进制	由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

5:进制转换

(1)其他进制到十进制
	系数：就是每一个位上的数值
	基数：x进制的基数就是x
	权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。
	结果：系数*基数^权次幂之和。
(2)十进制到其他进制
	除基取余，直到商为0，余数反转。
(3)进制转换的快速转换法
	A:十进制和二进制间的转换 8421码。
	B:二进制到八进制，十六进制的转换

6:变量

(1)程序的执行过程中，其值在某个范围内可以发生改变的量
(2)变量的定义格式：
	A:数据类型 变量名 = 初始化值;
	B:数据类型 变量名;
	  变量名 = 初始化值;

7:数据类型

基本数据类型：4类8种
引用数据类型：类，接口，数组。
	A:整数			占用字节数
		byte			1
		short			2
		int 			4
		long			8
	B:浮点数
		float			4
		double			8
	C:字符
		char			2
	D:布尔
		boolean			1
		整数默认是int类型，浮点数默认是double,长整数要加L或者l,单精度的浮点数要加F或者f。

8:运算符

(1)算术运算符
	A:+  -  *  /  %  ++  --
	B:+的用法
		a:加法
		b:正号
		c:字符串连接符
	C:/和%的区别
		/取得是商，%取得是余数
	D:++和--（自增 自减）
		A:使用
			a.单独使用
				a++或者++a效果一样。
			b.参与操作使用
				放在操作数的前面：先自增或者自减，再参与操作。
				放在操作数的后面：先参与操作，再自增或者自减。
(2)赋值运算符
	A:=  +=  -=  *=  /=  %=...
	B:=叫做赋值运算符，也是最基本的赋值运算符
		int x = 8; 把8赋值给int类型的变量x。
	C:扩展的赋值运算符的特点
		隐含了自动强制转换。
(3)比较运算符
	==  !=  >  >=  <  <= 最终结果是boolean类型。
(4)逻辑运算符
	A:&  |  ^  !  &&  || 逻辑运算符用于连接boolean类型
		&:有false则false
		|:有true则true
		^:相同则false，不同则true。
			情侣关系。
		!:非true则false，非false则true
		&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
		||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
(5)位运算符
	^的特殊用法
		一个数据针对另一个数据位异或两次，该数不变
(6)三元运算符
	A:格式
		比较表达式?表达式1:表达式2;
	B:执行流程：
		首先计算比较表达式的值，看是true还是false。
		如果是true，表达式1就是结果。
		如果是false，表达式2就是结果。
	C:案例：
		a:比较两个数据是否相等
		b:获取两个数据中的最大值
		c:获取三个数据中的最大值

正则表达式

	字符
		x 字符 x。举例：'a'表示字符a
		\\ 反斜线字符。
		\n 新行（换行）符 ('\u000A') 
		\r 回车符 ('\u000D')
		
	字符类
		[abc] a、b 或 c（简单类） 
		[^abc] 任何字符，除了 a、b 或 c（否定） 
		[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
		[0-9] 0到9的字符都包括
		
	预定义字符类
		. 任何字符。我的就是.字符本身，怎么表示呢? \.
		\d 数字：[0-9]
		\w 单词字符：[a-zA-Z_0-9]
			在正则表达式里面组成单词的东西必须有这些东西组成

	边界匹配器
		^ 行的开头 
		$ 行的结尾 
		\b 单词边界
			就是不是单词字符的地方。
			举例：hello world?haha;heihei
		
	Greedy 数量词 
		X? X，一次或一次也没有
		X* X，零次或多次
		X+ X，一次或多次
		X{n} X，恰好 n 次 
		X{n,} X，至少 n 次 
		X{n,m} X，至少 n 次，但是不超过 m 次 

常见功能

	//判断功能
			public boolean matches(String regex)
	//分割功能
			public String[] split(String regex)
	//替换功能
			public String replaceAll(String regex,String replacement)
	//获取功能
		//Pattern和Matcher
			Pattern p = Pattern.compile("a*b");
			Matcher m = p.matcher("aaaaab");
		//find():查找存不存在
		//group():获取刚才查找过的数据

Java基础

1：实际开发中，数据是变化的，为了提高程序的灵活性，加入键盘录入数据。

	//导包
		import java.util.Scanner;
	//创建对象
		Scanner sc = new Scanner(System.in);
	//获取数据
		int x = sc.nextInt();
		String y = sc.nextLine();

2:Java基础方法
格式：

	修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
		方法体语句;
		return 返回值;
	}

	修饰符: public static
	返回值类型：就是功能结果的数据类型
	方法名：起个名字方便调用该方法。
	参数类型：参数的数据类型
	参数名：变量
	参数分类：
		实参：实际参与运算的数据
		形参：方法上定义的，用于接收实际参数的变量
	方法体语句：就是完成功能的代码块
	return：结束方法
	返回值：就是功能的结果，由return带给调用者。
(3)两个明确：
	返回值类型：结果的数据类型
	参数列表：参数的个数及对应的数据类型
(4)方法调用
	A:有明确返回值的方法
		单独调用、输出调用、赋值调用
	B:void类型修饰的方法
		a:单独调用
(5)方法的注意事项
	A:方法不调用不执行
	B:方法之间是平级关系，不能嵌套定义
	C:方法定义的时候，参数是用，隔开的
	D:方法在调用的时候，不用在传递数据类型
	E:如果方法有明确的返回值类型，就必须有return语句返回。
(7)方法重载
	在同一个类中，方法名相同，参数列表不同。与返回值无关。
	参数列表不同：
		参数的个数不同。
		参数的对应的数据类型不同。

3:数组

(1)数组：存储同一种数据类型的多个元素的容器。
(2)特点：每一个元素都有编号，从0开始。编号的专业叫法：索引
(3)定义格式：数据类型[] 数组名;
(4)数组的初始化：动态初始化、静态初始化
(5)Java的内存分配
	A:栈 存储局部变量
	B:堆 存储所有new出来的
	C:方法区
	D:本地方法区(系统相关)
	E:寄存器(CPU使用)
(6)数组的常见操作

  	//遍历方式一：
		public static void printArray(int[] arr) {
			for(int x=0; x<arr.length; x++) {
				System.out.println(arr[x]);
			}
		}	
	//遍历方式二：
		public static void printArray(int[] arr) {
			System.out.print("[");
			for(int x=0; x<arr.length; x++) {
				if(x == arr.length-1) {
					System.out.println(arr[x]+"]");
				}else {
					System.out.println(arr[x]+", ");
				}
			}
		}

4:二维数组

格式：
	A:数据类型[][] 数组名 = new 数据类型[m][n];
	B:数据类型[][] 数组名 = new 数据类型[m][];
	C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
	D:数据类型[][] 数组名 = {{...},{...},{...}};

面向对象

面向对象的思想特点

	面向对象是基于面向过程的编程思想是一种更符合我们思考习惯的思想，把复杂的事情简单化，让我们从执行者变成了指挥者。

类与对象

	类是一组相关的属性和行为的集合。是一个抽象的概念。
	对象是该类事物的具体存在，是一个具体的实例。(对象)		  
	  举例：
		学生：类
		班长：对象
   类的定义及使用
	A:类的定义
		成员变量	定义格式和以前一样，就是位置不同，在类中，方法外。
		成员方法	定义格式和以前一样，就是去掉了static。
	B:使用类的内容
		格式：类名 对象名 =  new 类名();
		对象名.成员变量
		对象名.成员方法()

Java程序的开发，设计和特征

	A:开发：就是不断的创建对象，通过对象调用功能
	B:设计：就是管理和维护对象间的关系
	C:特征
		a:封装
		b:继承
		c:多态

匿名对象

无名字的对象
	A:调用方法，仅仅只调用一次的时候。
	b:可以作为实际参数传递。	

封装

(1)隐藏实现细节，提供公共的访问方式
(2)好处：
	A:隐藏实现细节，提供公共的访问方式
	B:提高代码的复用性
	C:提高代码的安全性
(3)设计原则
	把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
(4)private是封装的一种体现。
	封装：类，方法，private修饰成员变量

private

(1)定义私有，可以修饰成员变量和成员方法
(2)特点：
	被private修饰的后的成员只能在本类中被访问
(3)private的应用：
	提供对应的getXxx()/setXxx()方法

this关键字

代表当前类的引用对象，哪个对象调用方法，该方法内部的this就代表那个对象解决了局部变量隐藏成员变量的问题

构造方法

(1)作用：用于对对象的数据进行初始化
(2)格式：
	A:方法名和类名相同
	B:没有返回值类型，连void都不能有
	C:没有返回值

//学生类
class Student {
           //定义成员变量
			private String name;
			private int age;
			//无参构造方法
			public Student(){}
			//带参构造方法
			public Student(String name,int age) {
				this.name = name;
				this.age = age;
			}
			//生成get set方法
			public String getName() {
				return name;
			}
			
			public void setName(String name) {
				this.name = name;
			}
			
			public int getAge() {
				return age;
			}
			
			public void setAge(int age) {
				this.age = age;
			}
		}

static关键字

(1)静态，可以修饰成员变量和成员方法。
(2)静态的特点：
	A:随着类的加载而加载
	B:优先与对象存在
	C:被类的所有对象共享
	D:可以通过类名调用			

继承

关键字extends表示

	//格式
	class 子类名 extends 父类名 {}

继承提高了代码的复用性、提高了代码的维护性、让类与类产生了一个关系(多态)

Java中继承的特点

	A:Java中类只支持单继承
	B:Java中可以多重继承(继承体系)

继承的注意事项

	A:子类不能继承父类的私有成员
	B:子类不能继承父类的构造方法，但是可以通过super去访问
	C:不要为了部分功能而去继承

final关键字

final可以修饰类，方法，变量。
特点：
	A:它修饰的类，不能被继承。
	B:它修饰的方法，不能被重写。
	C:它修饰的变量，是一个常量。	

多态

多态就是同一个对象在不同时刻体现出来的不同状态。
多态的前提：
	A:有继承或者实现关系。
	B:有方法重写。
	C:有父类或者父接口引用指向子类对象。
多态的分类：

	//具体类多态
		class Fu {}
		class Zi extends Fu {}
		Fu f = new Zi();
	//抽象类多态
		abstract class Fu {}
		class Zi extends Fu {}
		Fu f = new Zi();
	//接口多态
		interface Fu {}
		class Zi implements Fu {}
		Fu f = new Zi();

抽象类

如果在一个类中如果有抽象方法，该类必须定义为抽象类。
抽象类的特点
	A:抽象类和抽象方法必须用关键字abstract修饰
	B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
	C:抽象类不能实例化
	D:抽象类的子类
		a:是一个抽象类。
		b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
抽象类的成员特点：
	A:成员变量
		有变量，有常量
	B:构造方法
		有构造方法
	C:成员方法
		有抽象，有非抽象

接口

//接口用关键字interface修饰
	interface 接口名 {}
//类实现接口用implements修饰
	class 类名 implements 接口名 {}

包

包其实就是文件夹
作用：
	A:区分同名的类
	B:对类进行分类管理
		a:按照功能分
		b:按照模块分
包的定义
	package 包名;
	多级包用.分开。		

导包

import 包名...类名;

权限修饰符

权限修饰符： 本类	同一个包下	不同包下的子类	不同包下的无关类
private		  Y
默认		  Y		    Y
protected	  Y		    Y			Y
public		  Y		    Y			Y				Y

常见的修饰符

(1)分类：
	权限修饰符：private,默认,protected,public
	状态修饰符：static,final
	抽象修饰符：abstract
(2)常见的类及其组成的修饰
	类：
		默认,public,final,abstract
		常用的：public
	成员变量：
		private,默认,protected,public,static,final
		常用的：private
	构造方法：
		private,默认,protected,public
		常用的：public
	成员方法：
		private,默认,protected,public,static,final,abstract
		常用的：public

	    public static final int X = 10;
		public static void show() {}
		public final void show() {}
		public abstract void show();

内部类

(1)把类定义在另一个类的内部，该类就被称为内部类。
	举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问规则
	A:可以直接访问外部类的成员，包括私有
	B:外部类要想访问内部类成员，必须创建对象
(3)内部类的分类
	A:成员内部类
	B:局部内部类
(4)成员内部类
	A:private 为了数据的安全性
	B:static 为了访问的方便性

这之前就把知识点书写完毕了，小伙伴们下一阶段来啦，请把住扶手我们即将发车！！！

具体类及使用方式

Object类

(1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。
(2)Object类的构造方法有一个，并且是无参构造
(3)要掌握的方法：
	A:toString()
		返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。
		这个表示其实是没有意义的，一般子类都会重写该方法。
	B:equals()
		比较两个对象是否相同。默认情况下，比较的是地址值是否相同。
		而比较地址值是没有意义的，所以，一般子类也会重写该方法。
(4)要了解的方法：
	A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。
	B:getClass() 返回对象的字节码文件对象。	
	C:finalize() 用于垃圾回收，在不确定的时间
	D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。		

String类

多个字符组成的一串数据，其实它可以和字符数组进行相互转换。

//构造方法
	public String()
	public String(byte[] bytes)
	public String(byte[] bytes,int offset,int length)
	public String(char[] value)
	public String(char[] value,int offset,int count)
	public String(String original)
//==和equals()
	String s1 = new String("hello");
	String s2 = new String("hello");
	System.out.println(s1 == s2);// false
	System.out.println(s1.equals(s2));// true

	String s3 = new String("hello");
	String s4 = "hello";
	System.out.println(s3 == s4);// false
	System.out.println(s3.equals(s4));// true

	String s5 = "hello";
	String s6 = "hello";
	System.out.println(s5 == s6);// true
	System.out.println(s5.equals(s6));// true

字符串的拼接

	String s1 = "hello";
	String s2 = "world";
	String s3 = "helloworld";
	System.out.println(s3 == s1 + s2);// false
	System.out.println(s3.equals((s1 + s2)));// true
	System.out.println(s3.equals("hello" + "world"));// true

字符串的功能

//判断功能
		boolean equals(Object obj)
		boolean equalsIgnoreCase(String str)
		boolean contains(String str)
		boolean startsWith(String str)
		boolean endsWith(String str)
		boolean isEmpty()
//获取功能
		int length()
		char charAt(int index)
		int indexOf(int ch)
		int indexOf(String str)
		int indexOf(int ch,int fromIndex)
		int indexOf(String str,int fromIndex)
		String substring(int start)
		String substring(int start,int end)
//转换功能
		byte[] getBytes()
		char[] toCharArray()
		static String valueOf(char[] chs)
		static String valueOf(int i)
		String toLowerCase()
		String toUpperCase()
		String concat(String str)
//其他功能
	//替换功能 
		String replace(char old,char new)
		String replace(String old,String new)
	//去空格功能
		String trim()
	//按字典比较功能
		int compareTo(String str)
		int compareToIgnoreCase(String str) 

StringBuffer

使用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了字符串缓冲区类。StringBuffer供我们使用。

		StringBuffer()
		StringBuffer(int size)
		StringBuffer(String str)

StringBuffer的常见功能

	添加功能、删除功能、替换功能、反转功能、截取功能

StringBuffer：同步的，数据安全，效率低。
StringBuilder：不同步的，数据不安全，效率高。

Arrays类

//排序
	//冒泡排序：相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。
			
			public static void bubbleSort(int[] arr) {
				for(int x=0; x<arr.length-1; x++) {
					for(int y=0; y<arr.length-1-x; y++) {
						if(arr[y] > arr[y+1]) {
							int temp = arr[y];
							arr[y] = arr[y+1];
							arr[y+1] = temp;
						}
					}
				}
			}
			
	//选择排序：把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。
			
			public static void selectSort(int[] arr) {
				for(int x=0; x<arr.length-1; x++) {
					for(int y=x+1; y<arr.length; y++) {
						if(arr[y] < arr[x]) {
							int temp = arr[x];
							arr[x] = arr[y];
							arr[y] = temp;
						}
					}
				}
			}
//查找
	//基本查找：针对数组无序的情况
			
			public static int getIndex(int[] arr,int value) {
				int index = -1;
				
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						index = x;
						break;
					}
				}
				return index;
			}
	//二分查找(折半查找)：针对数组有序的情况(千万不要先排序，在查找)
			
			public static int binarySearch(int[] arr,int value) {
				int min = 0;
				int max = arr.length-1;
				int mid = (min+max)/2;
				while(arr[mid] != value) {
					if(arr[mid] > value) {
						max = mid - 1;
					}else if(arr[mid] < value) {
						min = mid + 1;
					}
					if(min > max) {
						return -1;
					}
					mid = (min+max)/2;
				}
				return mid;
			}

Integer类

为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型
	byte 		Byte
	short		Short
	int			Integer
	long		Long
	float		Float
	double		Double
	char		Character
	boolean		Boolean

		Integer i = new Integer(100);
		Integer i = new Integer("100");

JDK5的新特性

	自动装箱	基本类型--引用类型
	自动拆箱	引用类型--基本类型

System

系统类,提供了一些有用的字段和方法
成员方法
	A:运行垃圾回收器
	B:退出jvm
	C:获取当前时间的毫秒值
	D:数组复制

Date/DateFormat

Date是日期类，可以精确到毫秒。
	A:构造方法
		Date()
		Date(long time)
	B:成员方法
		getTime()
		setTime(long time)
	C:日期和毫秒值的相互转换
(2)DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat
	A:SimpleDateFormat(String pattern) 给定模式
		yyyy-MM-dd HH:mm:ss
	B:日期和字符串的转换
		a:Date -- String
			format()
			
		b:String -- Date
			parse()

集合

集合(Collection)

(1)集合的由来?
	我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
	而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
(2)集合和数组的区别?
	A:长度区别
		数组固定
		集合可变
	B:内容区别
		数组可以是基本类型，也可以是引用类型
		集合只能是引用类型
	C:元素内容
		数组只能存储同一种类型
		集合可以存储不同类型(其实集合一般存储的也是同一种类型)
(3)集合的继承体系结构?
	由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
	Collection
		|--List
			|--ArrayList
			|--Vector
			|--LinkedList
		|--Set
			|--HashSet
			|--TreeSet
(4)Collection的功能概述
	A:添加功能
	B:删除功能
	C:判断功能
	D:获取功能
	E:长度功能
	F:交集(了解)
	G:把集合转数组(了解)
(5)Collection集合的遍历
	A:把集合转数组
	B:迭代器(集合专用方式)
(6)迭代器
	A:是集合的获取元素的方式。
	B:是依赖于集合而存在的。
(7)Collection集合的案例(遍历方式 迭代器)

//存储字符串并遍历
			import java.util.Collection;
			import java.util.ArrayList;
			import java.util.Iterator;
			
			public class CollectionDemo {
				public static void main(String[] args) {
					//创建集合对象
					Collection c = new ArrayList();
					//创建并添加元素
					c.add("hello");
					c.add("world");
					c.add("java");
					//遍历集合
					Iterator it = c.iterator();
					while(it.hasNext()) {
						String s =(String) it.next();
						System.out.println(s);
					}
				}
			}
		
//存储自定义对象并遍历
			public class Student {
				private String name;
				private int age;
				
				public Student(){}
				
				public Student(String name,int age) {
					this.name = name;
					this.age = age;
				}
				//自己生成 getXxx()/setXxx()
			}
			import java.util.Collection;
			import java.util.ArrayList;
			import java.util.Iterator;
			
			public class StudentDemo {
				public static void main(String[] args) {
					//创建集合对象
					Collection c = new ArrayList();		
					//创建学生对象
					Student s1 = new Student("小红",11);
					Student s2 = new Student("小明",12);		
					//添加元素
					c.add(s1);
					c.add(s2);		
					//遍历集合
					Iterator it = c.iterator();
					while(it.hasNext()) {
						Student s = (Student)it.next();
						System.out.println(s.getName()+"---"+s.getAge());
					}
				}
			}

集合(List)

(1)List是Collection的子接口
	特点：有序(存储顺序和取出顺序一致)，可重复。
(2)List的特有功能：
	添加功能、删除功能、获取功能、迭代器功能、修改功能
(3)List集合的特有遍历功能

	//创建集合对象
			List list = new ArrayList();
			//创建并添加元素
			list.add("hello");
			list.add("world");
			list.add("java");
			//遍历集合
			Iterator it = list.iterator();
			for(int x=0; x<list.size(); x++) {
				String s =(String) list.get(x);
				System.out.println(s);
			}

常见数据结构

	A:栈 先进后出
	B:队列 先进先出
	C:数组 查询快，增删慢
	D:链表 查询慢，增删快

List的子类

(1)List的子类特点
	ArrayList:
		底层数据结构是数组，查询快，增删慢，线程不安全，效率高
	Vector:
		底层数据结构是数组，查询快，增删慢，线程安全，效率低
	LinkedList:
		底层数据结构是链表，查询慢，增删快，线程不安全，效率高
(2)ArrayList
		a:ArrayList存储字符串并遍历
		b:ArrayList存储自定义对象并遍历
(3)Vector
	有特有功能
		a:添加
			public void addElement(E obj)		--	add()
		b:获取
			public E elementAt(int index)		--	get()
			public Enumeration elements()	--  iterator()
		c:Vector存储字符串并遍历
		d:Vector存储自定义对象并遍历
(4)LinkedList
	A:有特有功能	
		a:添加
			addFirst()
			addLast()
		b:删除
			removeFirst()
			removeLast()
		c:获取
			getFirst()
			getLast()
		d:LinkedList存储字符串并遍历
		e:LinkedList存储自定义对象并遍历

泛型

(1)泛型概述
	是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
	<数据类型>
	注意：该数据类型只能是引用类型。
(3)好处：
	A:把运行时期的问题提前到了编译期间
	B:避免了强制类型转换
	C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型高级通配符
		?
		? extends E
		? super E

增强for循环(foreach)

增强for是for循环的一种
格式：
	for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {
		使用该变量即可，该变量其实就是数组或者集合中的元素。
	}

集合(Set)

Set集合的特点: 无序,唯一

HashSet集合

	A:底层数据结构是哈希表(是一个元素为链表的数组)
	B:哈希表底层依赖两个方法：hashCode()和equals()
	  执行顺序：
		首先比较哈希值是否相同
			相同：继续执行equals()方法
				返回true：元素重复了，不添加
				返回false：直接把元素添加到集合
			不同：就直接把元素添加到集合
	C:如何保证元素唯一性的呢?
		由hashCode()和equals()保证的
	D:开发的时候，代码非常的简单，自动生成即可。
	E:HashSet存储字符串并遍历
	F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)

TreeSet集合

	A:底层数据结构是红黑树(是一个自平衡的二叉树)
	B:保证元素的排序方式
		a:自然排序(元素具备比较性)
			让元素所属的类实现Comparable接口
		b:比较器排序(集合具备比较性)
			让集合构造方法接收Comparator的实现类对象	

Collection集合总结

Collection
	|--List	有序,可重复
		|--ArrayList
			底层数据结构是数组，查询快，增删慢。
			线程不安全，效率高
		|--Vector
			底层数据结构是数组，查询快，增删慢。
			线程安全，效率低
		|--LinkedList
			底层数据结构是链表，查询慢，增删快。
			线程不安全，效率高
	|--Set	无序,唯一
		|--HashSet
			底层数据结构是哈希表。
			如何保证元素唯一性的呢?
				依赖两个方法：hashCode()和equals()
				开发中自动生成这两个方法即可
			|--LinkedHashSet
				底层数据结构是链表和哈希表
				由链表保证元素有序
				由哈希表保证元素唯一
		|--TreeSet
			底层数据结构是红黑树。
			如何保证元素排序的呢?
				自然排序
				比较器排序
			如何保证元素唯一性的呢?
				根据比较的返回值是否是0来决定			

在集合中常见的数据结构
ArrayXxx:底层数据结构是数组，查询快，增删慢
LinkedXxx:底层数据结构是链表，查询慢，增删快
HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

Map

(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
(2)Map和Collection的区别?
	A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
	B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
(3)Map接口功能概述
	添加功能、:删除功能、判断功能、获取功能、长度功能
(4)Map集合的遍历
	A:键找值
		a:获取所有键的集合
		b:遍历键的集合,得到每一个键
		c:根据键到集合中去找值
	
	B:键值对对象找键和值
		a:获取所有的键值对对象的集合
		b:遍历键值对对象的集合，获取每一个键值对对象
		c:根据键值对对象去获取键和值

			Map<String,String> hm = new HashMap<String,String>();
			
			hm.put("it002","hello");
			hm.put("it003","world");
			hm.put("it001","java");
			
			//键找值
			Set<String> set = hm.keySet();
			for(String key : set) {
				String value = hm.get(key);
				System.out.println(key+"---"+value);
			}
			
			//键值对对象找键和值
			Set<Map.Entry<String,String>> set2 = hm.entrySet();
			for(Map.Entry<String,String> me : set2) {
				String key = me.getKey();
				String value = me.getValue();
				System.out.println(key+"---"+value);
			}

小伙伴们再坚持坚持，坚持就是胜利！！！

异常

异常是指程序出现的不正常的情况。
异常的体系
	Throwable
		|--Error	严重问题，通常不处理。
		|--Exception
			|--RuntimeException	运行期异常，我们需要修正代码
			|--非RuntimeException 编译期异常，必须处理，否则程序编译不通过
(3)异常的处理：
	A:JVM的默认处理
		把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。
	B:自己处理
		a:try...catch...finally
			自己编写处理代码,后面的程序可以继续执行
		b:throws
			把自己处理不了的，在方法上声明，告诉调用者，这里有问题
(4)throw和throws是的区别
		throw:
			在方法体中,后面跟的是异常对象名,并且只能是一个
			throw抛出的是一个异常对象，说明这里肯定有一个异常产生了
		throws:
			在方法声明上,后面跟的是异常的类名,可以是多个
			throws是声明方法有异常，是一种可能性，这个异常并不一定会产生
(5)finally关键字
	finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了
(6)异常处理的形式
		try...catch...finally
		try...catch...
		try...catch...catch...
		try...catch...catch...fianlly
		try...finally
(7)自定义异常
	继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可
(8)异常的注意实现
	A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常 
	B:父的方法没有异常抛出,子的重写方法不能有异常抛出
	C:父的方法抛出多个异常,子的重写方法必须比父少或者小

IO流

IO流不做太详细介绍，想要了解看完本文在自行脑补。嘿嘿嘿

IO流

(1)IO用于在设备间进行数据传输的操作	
(2)分类：
	A:流向
		输入流	读取数据
		输出流	写出数据
	B:数据类型
		字节流	
				字节输入流------InputSream
				字节输出流------OutputSream
		字符流
				字符输入流------Reader
				字符输出流------Writer

FileOutputStream写出数据

		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("aaa.txt");	
		//调用write()方法
		fos.write("hello".getBytes());
		//释放资源
		fos.close();

FileInputStream读取数据

		//创建字节输入流对象
			FileInputStream fis = new FileInputStream("aaa.txt");
			//调用read()方法
			//方式1
			int by = 0;
			while((by=fis.read())!=-1) {
				System.out.print((char)by);
			}
			//方式2
			byte[] bys = new byte[1024];
			int len = 0;
			while((len=fis.read(bys))!=-1) {
				System.out.print(new String(bys,0,len));
			}
			//释放资源
			fis.close();

字节缓冲区流

	A:BufferedOutputStream
	B:BufferedInputStream	

IO流分类

	字节流：
		InputStream
			FileInputStream
			BufferedInputStream
		OutputStream
			FileOutputStream
			BufferedOutputStream
	
	字符流：
		Reader
			FileReader
			BufferedReader
		Writer
			FileWriter
			BufferedWriter

IO流总结

IO流
	|--字节流
		|--字节输入流
			InputStream
				int read():一次读取一个字节
				int read(byte[] bys):一次读取一个字节数组
			
				|--FileInputStream
				|--BufferedInputStream
		|--字节输出流
			OutputStream
				void write(int by):一次写一个字节
				void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
				
				|--FileOutputStream
				|--BufferedOutputStream
	|--字符流
		|--字符输入流
			Reader
				int read():一次读取一个字符
				int read(char[] chs):一次读取一个字符数组
				
				|--InputStreamReader
					|--FileReader
				|--BufferedReader
					String readLine():一次读取一个字符串
		|--字符输出流
			Writer
				void write(int ch):一次写一个字符
				void write(char[] chs,int index,int len):一次写一个字符数组的一部分
				
				|--OutputStreamWriter
					|--FileWriter
				|--BufferedWriter
					void newLine():写一个换行符
					
					void write(String line):一次写一个字符串

数据操作流(操作基本类型数据的流)

可以操作基本类型的数据
流对象名称	
	DataInputStream
	DataOutputStream

内存操作流

有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。
	A: ByteArrayInputStream,ByteArrayOutputStream
	B: CharArrayReader,CharArrayWriter
	C: StringReader,StringWriter

打印流

字节打印流，字符打印流
(2)特点：
	A:只操作目的地,不操作数据源
	B:可以操作任意类型的数据
	C:如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新
	D:可以直接操作文件

//复制文本文件
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
		String line = null;
		while((line=br.readLine())!=null) {
			pw.println(line);
		}	
		pw.close();
		br.close();

标准输入输出流

System类下面有这样的两个字段
	in 标准输入流
	out 标准输出流
(2)三种键盘录入方式
	A:main方法的args接收参数
	B:System.in通过BufferedReader进行包装
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	C:Scanner
		Scanner sc = new Scanner(System.in);
(3)输出语句的原理和如何使用字符流输出数据
	A:原理
		System.out.println("helloworld");
		PrintStream ps = System.out;
		ps.println("helloworld");
	B:把System.out用字符缓冲流包装一下使用
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

随机访问流

可以按照文件指针的位置写数据和读数据。获取和改变文件指针的位置

合并流

把多个输入流的数据写到一个输出流中。

//构造方法
		SequenceInputStream(InputStream s1, InputStream s2) 
		SequenceInputStream(Enumeration<? extends InputStream> e) 

序列化流

可以把对象写入文本文件或者在网络中传输
(1)如何实现序列化呢?
	让被序列化的对象所属类实现序列化接口。
	该接口是一个标记接口。没有功能需要实现。
(2)注意问题：
	把数据写到文件后，在去修改类会产生一个问题。
	如何解决该问题呢?
		在类文件中，给出一个固定的序列化id值。
		而且，这样也可以解决黄色警告线问题

快结束啦！！！

多线程

	进程：正在执行的应用程序
	线程：进程的执行单元，执行路径
	单线程：一个应用程序只有一条执行路径
	多线程：一个应用程序有多条执行路径
	多进程的意义是提高CPU的使用率，提高应用程序的使用率。

Java程序的运行原理及JVM的启动是多线程的吗?

	A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
	B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。

多线程的实现方案

	A:继承Thread类
	B:实现Runnable接口

线程的调度和优先级问题

	A:线程的调度
		a:分时调度
		b:抢占式调度 (Java采用的是该调度方式)
	B:获取和设置线程优先级
		a:默认是5
		b:范围是1-10

线程的控制

	休眠线程、加入线程、礼让线程、后台线程、终止线程

线程的生命周期

	A:新建
	B:就绪
	C:运行
	D:阻塞
	E:死亡

JDK5以后的针对线程的锁定操作和释放操作(Lock锁)、死锁问题、线程组、线程池自行查找，我说的肯定不如你自己查，就不误导你们了！！！

设计模式

(1)面试对象的常见设计原则
	单一
	开闭
	里氏
	依赖注入
	接口
	迪米特
(2)设计模式概述和分类
	A:经验的总结
	B:三类
		创建型
		结构型
		行为型
(3)改进的设计模式
	A:简单工厂模式
	B:工厂方法模式
	C:单例模式
		a:饿汉式
		b:懒汉式
(4)Runtime
	JDK提供的一个单例模式应用的类。
	还可以调用dos命令。

网络编程

网络编程：用Java语言实现计算机间数据的信息传递和资源共享

网络编程的三要素

	A:IP地址
		a:点分十进制
		b:IP地址的组成
		c:IP地址的分类
		d:dos命令
		e:InetAddress
	B:端口
		是应用程序的标识。范围：0-65535。其中0-1024不建议使用。
	C:协议
		UDP:数据打包,有限制,不连接,效率高,不可靠
		TCP:建立数据通道,无限制,效率低,可靠

Socket机制

	A:通信两端都应该有Socket对象
	B:所有的通信都是通过Socket间的IO进行操作的

UDP协议发送和接收数据

	发送：
		创建UDP发送端的Socket对象
		创建数据并把数据打包
		发送数据
		释放资源
		
	接收：
		创建UDP接收端的Socket对象
		创建数据包用于接收数据
		接收数据
		解析数据包
		释放资源

TCP协议发送和接收数据

	发送：
		创建TCP客户端的Socket对象
		获取输出流，写数据
		释放资源
		
	接收：
		创建TCP服务器端的Socket对象
		监听客户端连接
		获取输入流，读取数据
		释放资源

反射

(1)类的加载及类加载器
(2)反射：
	通过字节码文件对象，去使用成员变量，构造方法，成员方法
(3)反射的使用
	A:通过反射获取构造方法并使用
	B:通过反射获取成员变量并使用
	C:通过反射获取成员方法并使用

结束语

这里我的JavaSE就总结完毕了，个人能力有限也就是查资料加上自己的个人对知识的理解总结了以上这些，仅供大家参考！！！这也是我人生第一次在csdn上发博客，请轻，多多点
果感觉有用请多多点赞