什么是Java?
Java是一种编程语言，Java可以撰写跨平台应用软件，是由Sun 公司与1995年推出的程序设计语言和Java平台（JavaEE，JavaME，JavaSE）的总称。
Java的历史
2010年Oracle公司收购了Java。
Java的体系
JavaSE java平台标准版 桌面版
JavaEE java平台企业版 大型网站
JavaME java平台微型版 手机 移动终端
Java的开发环境
Eclipse、Myeclipse、InteliJ Idea、Jbuilder等等。
Java程序的运行
运行java需要在java虚拟机中，也叫做JVM，它是java运行环境的一部分，java运行环境又称为JRE。只要电脑中安装了JRE，就可以运行java程序。
1.源文件：Java的源代码是.java结尾的文件。
2.编译：然后通过编译器把源文件翻译成字节码文件，为.class文件
3.运行：最后使用解释器来运行字节码文件。
JDK是Java语言的开发包，可以将.java文件编译为可执行的Java程序。
可执行Java程序需要JVM才可以运行。
JRE（运行环境）包含了JVM（虚拟机）。
JDK包含了JRE
什么是JRE？
JRE（Java Runtime Environment，java运行环境），运行Java程序所需要的环境集合，包含了JVM标准实现及Java核心类库，仅能够完成java的运行，无法对java进行编译、调试等。
什么是JDK？
JDK（Java Development Kit）是Java语言的软件开发工具包（SDK），是面向Java开发者发布的Java套件。
JDK包含的基本组件包括：编译器、Jar打包工具、Javadoc文档生成器、Debug调试器、头文件生成器、反汇编器、监控工具等。
JDK中包含完整的JRE
InteiliJ IDEA
安装Idea、可添加插件->Preferences->Plugins->Install
常用插件：
activate-power-mode 打字轰炸效果
CodeGlance 类似minimap 右边小地图
IDEA快捷键：
option+command+L 代码格式化
注视 command+/
导入包 option+回车
移动代码行 command+shift+上下
进入类 command+左键点击
调试：
F7、F8 下一步
检查是否安装java
打开终端 输入 java -version 如果安装了会提示当前安装的版本 如果没安装需要安装https://java.com/zh_CN/
然后安装 java jdk
项目结构
src项目源文件 com.xxx.baidawei 每一个.一个文件夹
Libraries 引用的包文件
注视： //单行 /**/ 多行 文档注视/** */
关键字：Java中的关键字均为小写，如 class void static public等等。
变量 可变的量 为内存中的数据起别名
常量 不可变的量
数据类型：
基本数据类型：整数（byte 、short、int、long）、小数（float、double）、字符（char）、布尔（boolean）
Java中默认的整数类型是int类型，如果定义long需要后面加一个L。
Java中默认的浮点类型是double类型，如果定义为float类型后面需要加一个F。
引用数据类型：字符串（String）、数组、类、接口
定义变量 类型 变量1，变量2，变量n
byte score; int sumScore;long fileSize; float x,y; short age; double result; char sex;boolean isa; String name;大写的string
变量的初始化
age=23;score = 70+5;i=10/5;result=3.5;sex=‘男’;isa = true;name=‘张飞’;
变量的命名规则：首字母是 英文字母、$或下划线，由字母数字、下划线组成，尽量有意义如sex，在java中变量首字母小写 与类名、接口名区分，驼峰命名法，sumSore。
变量作用域
大括号作为语句块的范围，称为作用域。作用域中变量不能重复定义。离开作用域变量所分配的内存会被JVM回收。
数据类型转换：
byte -> short -> int ->long -> float -> double
1.自动转换 范围小的可以直接转换为范围大的。
2.强制转换 范围大的转换为范围小的。 int a12 = (int)a11;
运算符：
算数运算符：
+、-、*、/、%、 加减乘除取余
自增、自减、自乘、自除；
int+=1;int=int+1; int-=1; int = int - 1;
++I;先加 i++; 先运算后++；
赋值运算符：
= 把右边的值赋值给左边的变量；
比较运算符：
>、<、>=、<=、!=、== 大于、小于、大于等于、小于等于、不等于、等于
逻辑运算符：
& 与 两边都为true 结果为true
| 或 有一遍为true 结果为true
^ 异或 true ^ false 结果True 两边相同为false
! 非 取反 不为true 结果为true
&& 短路与 一边是false ，另一边不运行 效率高于一个的
|| 短路或 一边是true，另一边不运行 效率高于一个的
三元运算符：
(布尔表达式) ? (真结果1) : (假结果2) 3>1?’big’:’small’;
Scanner类
在命令行中接受键盘输入
1.引入包 import java.util.Scanner;
2.实例化 Scanner sc = new Scanner(System.in);
3.使用方法 sc.nextInt(); 接受输入的整数 sc.next();接受输入的字符串
Random类
产生随机数
1.引入包 import java.util.Random;
2.实例化 Random r = new Random();
3.使用 r.nextInt(99); //范围 生成一个随机数
流程控制语句
IF语句 如果满足某个条件 就执行
If(1==1 || 2 ==2){
}else if(1 != 1 && 1 != 3){
}else{
}
Swtich语句
switch(a){
Case 1:
case 2:
Break;
Default:
Break;
}
循环语句
while循环 先判断再循环 条件为真就循环
While(I<5){
I++;
}
do..while循环 先执行再判断
do{
}while(true);
for循环
指定次数的循环
for（int I = 1;i<10;i++){
}
break语句
停止循环
continue语句
结束本次，继续下次循环。
数组：
数据类型[] 数组名 = new 数据类型[元素个数];
下标从0开始,最大值长度-1.超出报错。
int [] nums = new int[3];
nums[2] = 1;
//定义的同时对数据进行赋值
int[] arr = new int[]{1,2,3,4,4};
int[] arr= {1,2,3,4,5}; //简化版
//遍历数组
for(int I= 0;i<arr.length;i++){
System.out.println(arr[i]);
}
二维数组：
//二维数组中有三个一纬数组
//三个一纬数组的长度是四
int[][] arrs = new int[3][4];
arrs[0][0] = 1;
System.out.println(arrs[0][0]);
int[][] arrs = {{1,2,3,4,5},{1,2,3,4,5}};
for(int i = 0;i<arrs.length;i++){
for(int j = 0;j<arrs[i].length;j++){
System.out.println(arrs[i][j]);
}
}
方法：
修饰符 返回值类型 方法名(参数1，参数2,……){
return 返回值;
}
返回值的结果要与返回类型一致。
public static void main(String[] args) {
System.out.println(sayHi());
}
public static String sayHi(){
return "Hi";
}
方法的重载：
在同一个类中，方法名一致，参数列表不同即可。
public static void main(String[] args) {
System.out.println(sayHi("david"));
}
public static String sayHi(){
return "Hi";
}
public static String sayHi(String name){
return name + "Hi";
}
方法中参数是基本数据类型：
方法内改变值不影响原值。
方法中参数是引用数据类型：
方法内改变值影响原值。
类：
public class 类名{
属性定义
修饰符 数据类型 = 值；
方法定义
修饰符 返回值类型 方法名（参数列表）{
}
}
public class Phone {
public int Size = 14;
public String Color = "Red";
public String Call(String number){
return "正在呼叫："+number;
}
}
public static void main(String[] args) {
Phone p = new Phone();
System.out.print(p.Call("13845054318"));
p.Size = 100;
System.out.print(p.Size);
}
ArrayList集合
1.导入包 import java.util.ArrayList;
2.创建对象 ArrayList<数据类型> 名 = new ArrayList<数据类型>();
数据类型不能是基本数据类型，必须是引用数据类型。
byte -> Byte
short -> Short
Int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean
常用方法：
Add() 添加元素
Get() 取出元素 索引取出
size() 返回长度
Set() 修改指定索引的元素
remove() 移除指定索引的元素
Clear() 清空
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(1);
nums.add(3);
nums.add(3);
nums.add(3);
nums.add(3);
for(int i = 0;i<nums.size();i++){
System.out.println(nums.get(i));
}
面向对象
三大特性：封装、集成、多态。
封装：隐藏具体实现的细节，对外提供可以访问的方式。便于调用者的使用。提高了复用性。
private 私有的
get、set方法
public class Phone {
private int size;
public void setSize(int s){
size = s;
}
public int getSize(){
return size;
}
}
this关键字
区分成员变量和局部变量同名的情况
this.size为属性
public class Phone {
private int size;
public void setSize(int s){
int size = 1;
this.size = s;
}
public int getSize(){
return this.size;
}
}
继承：子类自动拥有父类所有可继承的属性和方法。
class 子类 extends 父类{}
单继承，一个类只可以有一个父类
方法重写：子类方法名与父类一致，参数也一致。调用时如果子类有就调用子类的没有再调用父类的。
抽象类：
public abstract 返回值类型 方法名（参数）{}
抽象类不能被创建对象，因为抽象方法没有意义。
抽象类一定是个父类，如果没有子类重写他的方法，那么他将没有意义。
public abstract class Phone {
//抽象函数 没有方法体
public abstract void Call();
}
public abstract class Iphone extends Phone {
public void Work(){
System.out.println("abstract");
}
}
接口：
接口最主要的是用来解决多继承的弊端，将多继承这种机制在java中通过实现完成了。
public interface 接口名{
抽象方法1;
抽象方法2;
}
接口中的方法不能有方法体，属性必须为常量。方法可以不写public abstract
public interface Iphone{
//常量
public static final int Age = 18;
//抽象方法
public abstract void SayHi();
}
实现一个接口使用关键字implements，并且实现接口的全部方法。
public class Phone implements Iphone{
public void SayHi(){
System.out.print("接口"+ this.Age);
}
}
多实现：
A implements B,C
在一个类中可以同时继承并且实现多个接口
A extends B implements C,D
多态：
对象在调用同一个方法时表现出来的多种状态。
如：你在vs中按f1出现vs的帮助文档，在idea中按f1则会出现idea的使用帮助。
多态的三个必要条件：继承、重写、父类引用指向子类对象
父类类型或者接口类型 变量 = new 子类的对象();
Person p1 = new Student();
Person p2 = new Teacher();
instanceof关键字
比较运算符，返回真假，判断某个对象是否属于某种数据类型。
boolean result = 对象 instanceof 数据类型;
P1 instanceof Student(); //true
p2 instanceof Student(); //false
转型
向上转型：当有子类对象复制给一个负累引用时，就是向上转型，多态本身就是向上转型的过程。
向下转型：将负累引用转换为子类引用。强制转换。
Student stu =（person） p1；
构造方法：
创建对象时，初始化对象。 构造方法没有返回值类型。
如果没有自定义构造函数，系统会有一个默认无参的构造函数。
public class Person {
private String name;
private int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public void SayHi(){
System.out.println("我叫："+this.name+"；我今年："+this.age+"岁了");
}
}
public static void main(String[] args) {
Person p = new Person("david",18);
p.SayHi();
}
this关键字
可以在多个构造方法之间调用
public class Person {
private String name;
private int age;
Person(String name){
this.name = name;
}
Person(String name,int age){
this(name);
this.age = age;
}
public void SayHi(){
System.out.println("我叫："+this.name+"；我今年："+this.age+"岁了");
}
}
super关键字
在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句。
使用super(实参列表) 可以调用父类中的构造方法。
public class Chinese extends Person {
Chinese(String name,int age){
super(name,age);
}
}
public class Main {
public static void main(String[] args) {
Chinese c = new Chinese("david",18);
c.SayHi();
}
}
final 不可变
可以用来修饰类，类的成员，以及局部变量。
final修饰的类 不可以被继承，但是可以继承其他类。
final修饰的方法 不可以被子类重写。
final修饰的变量 称为常量，不会改变的值。
static 静态的
静态的方法可以直接 类名.方法名调用 不需要实例化
public class tai {
public static void SayTai(){
System.out.println("崩卡崩卡");
}
}
tai.SayTai();
静态不能调用非静态。
匿名对象
new person().say(); 只用一次
内部类
在一个类的内部定义一个类，成为内部类。
内部类可以访问外部类所有成员，哪怕是私有的。
// 外部类
public class Outer {
private String haha = "哈哈大笑";
//内部类
public class Inner{
public void HAHA(){
System.out.println(haha);
}
}
}
//访问方式 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
Outer.Inner inner = new Outer().new Inner();
inner.HAHA();
局部内部类
方法中的内部类
public void out(){
class Inner{
public void inner(){
System.out.println("内部类方法");
}
}
Inner in = new Inner();
in.inner();
}
调用out()方法时，自动调用内部类中的方法
匿名内部类
new interface(){ //实例化接口 实现接口方法
Public void smoking(){
}
}.smoking();
java中的包，其实就是电脑中的文件夹，包中方的是类文件。
命名规则，全部小写，域名反写、com.xxx.web
package david.web; 包的声明 在第一行
导入包
import david.web.Outer; 具体到类名
修饰符
public、private、protected、default
1.仅能在本类中使用 private
2.本包中的类可以访问不加修饰符
3.本包中的类与其他包中的子类可以访问 protected
4.所有包中的所有类 public
一个文件中只能有一个public修饰的类，如果用public修饰则类名必须与文件名相同。
API
java为我们封装好的一些类，直接使用即可。
Object
object是所有类的父类，object所有的方法，子类都能使用。
equals
比较两个对象是否相同。
toString()
返回该对象的字符串表示。
String类
字符串字面值是String其实是类的实例。
字符串一旦创建，字符串本身不能改变，但str变量中记录的地址是可以改变的。
String str = "abcdefghijklmnopq123456";
String str2 = new String("abcdefghijklmnopq123456");
System.out.println(str == str2); //false 引用类型数据，==比较的是对象的地址
System.out.println(str.equals(str2)); //true equals 比较的是对象的内容
常用方法：
length() 返回字符串长度 字符个数
substring(startIndex,endIndex) 截取字符串 返回从开始到结束的字符串
startsWith(String prefix) 检测是否以此字符串开头
endsWith(String suffix) 检测是否以此字符串结尾
contains(String str) 判断字符串是否包含str字符串
indexOf(String str) 返回制定字符串在字符串中第一次出现的索引 没有返回-1
getBytes() 返回byte数组
toCharArray() 返回字节数组
equals(object obj) 字符串与指定对象比较
equalsIgnoreCase() 比较字符串不考虑大小写
toUpperCase() 转换大写
toLowerCase() 转换小写
replace() 替换字符串，使用的字符串
Split() 参数分隔符 返回字符串数组
StringBuffer类
字符串缓冲区支持可变的字符串。
StringBuffer sb = new StringBuffer();
sb.append("开头"); //追加内容
sb.append("中间");
sb.insert(0,"在0插入");
//"在0插入开头中间";
sb.delete(1,4); //删除索引1到4的字符串
//在开头中间
sb.reverse(); //反转
System.out.println(sb.toString());
StringBuffer是线程安全的，所以速度慢一些。
StringBuilder 不是线程安全的，所以比较快。
正则表达式
用来定义匹配规则，检查一个字符串是否符合该规则。
\ 转义
换行
回车
[abc] 范围abc中有一个即可
[^abc] 取反 不能有abc中的一个
[a-zA-Z] 小写a到z及大写A-Z中任何一个都可以
[0-9] 匹配数字0到9之内
[a-zA-Z_0-9] 匹配字母下划线数字
预定义字符：
d 相当于0-9
w 相当于a-zA-Z
^ 代表的是行的开头
$ 代表的是行的结尾
单词边界
? 一次或一次也没有
* 0次或多次
+ 一次或多次
{n} 正好n次
{n,} 至少n次
{n,m} 至少n次，最多m次。
字符串.matches(regex) 返回真假
public static boolean checkQQ(String qq){
boolean result = qq.matches("^[1-9][0-9]{4,9}$");
return result;
}
邮箱验证
String email = "abc123@sina.com.cn";
boolean checkEmail = email.matches("[a-zA-Z0-9_]+@[a-zA-Z]+(\.[a-z]+)+");
System.out.print(checkEmail);
str.split(regex); 根据正则切割
String str = "192.168.0.2";
String[] strs = str.split("\.+");
for(int i =0;i<strs.length;i++){
System.out.println(strs[i]);
}
str.replaceAll(regex) 根据正则替换
String str = "192.168.0.2";
str = str.replaceAll("\.","*");
System.out.print(str);
Date类
时间原点：公园1970年1月1日，午夜0点。 毫秒值是0；
System.currentTimeMillis() 到今天的毫秒数
import java.util.Date;
Date date = new Date();
date.getTime(); //返回当前毫秒值
date.setTime(1521877860868L); //设置日期通过毫秒值
System.out.print(date);
日期格式化
import java.text.SimpleDateFormat;
SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = pattern.format(new Date());
System.out.println(date);
字符串转成Date对象
//有可能转换失败，所以要加异常。需要完全匹配规则
public static void main(String[] args) throws ParseException {
SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = pattern.parse("1995-12-1 12:12:12");
System.out.println(date);
}
Calendar日历类
抽象类，替换了很多Date中的方法。
Calendar.getInstance(); 获取默认时区和语言环境获得一个日历。
get() 方法 获取日历字段
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"-"+month+"-"+day);
Set() 方法 设置日历字段
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR,2088);
c.set(2099,4,5);
c.set(2099,4,5,12,30,0);
add() 方法
c.add(Calendar.DATE,5); 添加5天
c.add(Calendar.DATE,-5); 减少5天
活了多少天
Calendar my = Calendar.getInstance();
Calendar c = Calendar.getInstance();
my.set(1991,0,11);
long day = c.getTimeInMillis();
long myDay = my.getTimeInMillis();
System.out.println((day-myDay)/1000/60/60/24);
包装类
包装类中封装了一些实用的方法和常量。
Integer类 是int类型
Integer.parseInt("123”); //将字符串转换为int类型
Int转字符串
int num = 10;
System.out.println(num+""+12); //加双引号
方法2:
Integer.toString(num);
常量两个：
Integer.MAX_VALUE 最大值
Integer.MIN_VALUE 最小值
Byte类 是byte类型的包装类
Float类 是float类型的包装类
…
自动装箱：基本数据类型直接变成对象
Integer i = 1; //Integer i = new Integer(1); 1转换成引用各类型 装箱
自动拆箱：对象中的数据变回基本类型
i++; //自动拆箱 引用类型会转换回基本类型做运算
System类
System.exit(0); //终止虚拟机jvm
System.gc()
; //垃圾回收
System.getProperties(); //获取系统信息
System.arraycopy(); //复制数组
Math类
import java.lang.Math;
Math.abs(-9) 绝对值
Math.Max min 最大最小值
Math.pow（a,b）a的b次方
Math.random(); 随机数0.0-1.0之间
Math.round(double d) 四舍五入，取整数
Arrays类
import java.util.Arrays;
Arrays.sort(arrys) 排序数组 升序
Arrays.binarySearch(arrys,3) 查找值，返回出现的索引
Arrays.toString(arrys) 输出字符串
BigInteger类
超大整型数据，比Long还大。
import java.math.BigInteger;
加法：
BigInteger b1 = new BigInteger("1231231231231231233123");
BigInteger b2 = new BigInteger("1231231231231231233123");
System.out.println(b1.add(b2));
减法：
System.out.println(b1.subtract(b2));
乘法：
System.out.println(b1.multiply(b2));
除法：
System.out.println(b1.divide(b2));
BigDecimal类
高精度浮点运算
import java.math.BigDecimal;
//原因：计算机二进制中，表示浮点数不精确造成。
System.out.println(0.09+0.01); //0.09999999999999999
System.out.println(1.0-0.32); //0.6799999999999999
System.out.println(1.015*100); //101.49999999999999
System.out.println(1.301/100); //0.013009999999999999
BigDecimal b1 = new BigDecimal("0.09");
BigDecimal b2 = new BigDecimal("0.01");
//加法
System.out.println(b1.add(b2)); //0.10
//减法
System.out.println(b1.subtract(b2));//0.08
//乘法
System.out.println(b1.multiply(b2));//0.0009
//除法 第二个参数保留几位小数,有可能除不尽的时候会报错
System.out.println(b1.divide(b2,2));//9
BigDecimal b3 = new BigDecimal("1.601");
BigDecimal b4 = new BigDecimal("101");
//ROUND_UP 向上+1 ROUND_DOWN 直接舍去 ROUND_HALF_UP四舍五入
System.out.println(b3.divide(b4,4));//0.016
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_UP));//0.02
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_DOWN)); //0.01
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_UP)); //0.02
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_DOWN)); //0.02
Collection接口
是所有集合的根接口
集合Collection接口中的方法（所有实现类必须拥有的方法）。
//接口多态的方式调用
Collection<String> co = new ArrayList<String>();
//添加元素
co.add("abc");
co.add("bcd");
System.out.println(co);//[abc, bcd]
//清空集合中的元素
co.clear();
System.out.println(co);//[]
contains(object o) 判断对象是否存在于集合中，存在返回true。
co.contains("abc”);
toArray(); 将集合转成数组
Object[] obj = co.toArray();
for(int i = 0;i<obj.length;i++){
System.out.println(obj[i]);
}
remove(); 删除
co.remove("abc”); //删除第一个匹配的元素
Iterator接口 迭代器
Java中提供了许多集合，他们在存储时方式不同。取出时通过一种通用的方式。如果有就取出。
接口Iterator ：两个抽象方法
boolean hasNext() 判断集合中还有没有可以被取出的元素，如果有返回true。
next() 取出集合中的下一个元素
使用ArrayList集合的对象
Iterator it = array.iterator(); 运行结果就是Iterator接口的实现类对象
It是接口的实现类对象，调用方法hasNext和next集合元素迭代
Collection<String> co = new ArrayList<String>();
co.add("abc");
co.add("bcd");
co.add("abc");
Iterator<String> it = co.iterator();
while(it.hasNext()){
String val = it.next();
System.out.println(val);
}
for写法
for(Iterator<String> it = co.iterator();it.hasNext();){
System.out.println(it.next());
}
增强for循环
Jdk1.5以后出来的新特性，java.lang.Iterable。
collection（原集合根接口）开始继承Iterable。
格式：
for(数据类型 变量名 : 数组或集合){
System.out.println(变量名);
}
int[] nums = {1,2,3,4,5,6,6,6,6,4,3,2,23,4};
for(int n : nums){
System.out.println(n);
}
好处：代码少，方便遍历
弊端：没有索引，不能操作容器里面的元素
泛型
使用集合时，明确集合中的元素类型。不会像arrayList那样object强转异常。
Collection<String> coll = new ArrayList<String>();
Java泛型是伪泛型
ArrayList<String> 编译手段
arr.add(“”) 不是String的时候编译失败
但是编译后的class文件，是没有泛型的
修饰符 class 类名<代表泛型的变量> { }
例如，API中的ArrayList集合：
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
}
创建对象时，确定泛型的类型
例如，ArrayList<String> list = new ArrayList<String>();
此时，变量E的值就是String类型
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
}
例如，ArrayList<Integer> list = new ArrayList<Integer>();
此时，变量E的值就是Integer类型
class ArrayList<Integer>{
public boolean add(Integer e){ }
public Integer get(int index){ }
}
？泛型的通配符
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Main {
public static void main(String[] args){
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(1);
nums.add(2);
ArrayList<String> strs = new ArrayList<String>();
strs.add("abc");
strs.add("def");
iterator(nums);
iterator(strs);
}
public static void iterator(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
泛型的限定
//创建3个集合对象
ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
ArrayList<JingLi> jl = new ArrayList<JingLi>();
//每个集合存储自己的元素
cs.add(new ChuShi("张三", "后厨001"));
cs.add(new ChuShi("李四", "后厨002"));
fwy.add(new FuWuYuan("翠花", "服务部001"));
fwy.add(new FuWuYuan("酸菜", "服务部002"));
jl.add(new JingLi("小名", "董事会001", 123456789.32));
jl.add(new JingLi("小强", "董事会002", 123456789.33));
iterator(jl);
iterator(fwy);
iterator(cs);
//方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
public static void iterator(ArrayList<? extends Employee> array){
Iterator<? extends Employee> it = array.iterator();
while(it.hasNext()){
//获取出的next() 数据类型,是什么Employee
Employee e = it.next();
e.work();
}
}
List接口
有序的collection，可以对每个元素的插入位置进行精确的控制，根据整数索引控制。
可以存储重复元素。
继承Collection接口，实现类ArrayList、LinkedList。
并发修改异常
使用迭代器遍历集合时改变集合会报错。
Iterator<String> it = co.iterator();
while(it.hasNext()){
String val = it.next();
if(val==“abc”)
Co.add(“aa”); //迭代器工作时 不可以改变集合
System.out.println(val);
}
LinkedList类
import java.util.LinkedList;
对一个集合的操作如果大多是首尾操作那么推荐使用LinkedList类。
LinkedList<Integer> link = new LinkedList<Integer>();
link.add(1);
link.addLast(2);//添加到当前末尾
link.add(3);
link.addFirst(4); //添加到当前开头
if(!link.isEmpty()){ //link.size() != 0
System.out.println(link); //[4, 1, 2, 3]
System.out.println(link.getFirst()); //获取开头
System.out.println(link.getLast()); //获取结尾
}
link.removeFirst();
link.removeLast();
System.out.println(link);//[1, 2]
Set接口
不允许存储重复元素，取出可以使用迭代器、增强for。没有索引，无序的。
继承collection，实现类hashSet。
HashSet<String> set = new HashSet<String>();
set.add("haha1");
set.add("abc2");
set.add("def3");
set.add("ghi4");
for(String s : set){
System.out.println(s);
}
如果存入重复的，只存进去一个。
Map接口
键值对集合，不能重复key，常用集合为HashMap集合、LinkedHashMap集合。
HashMap<Integer,String> map = new HashMap<Integer,String>();
//添加键值对
map.put(1,"a");
map.put(2,"b");
map.put(1,"c"); //key重复 会覆盖原有value
System.out.println(map);//{1=c, 2=b}
String val = map.get(1); //get通过key获取value
System.out.println(val); //c
map.remove(1); //移除
//返回set keySet()返回所有key
Set<Integer> keys = map.keySet();
for(int i : keys){
System.out.println(i+"：" +map.get(i));
}
Entry 键值对对象
Entry将将只对的对应关系封装成了对象，在遍历map集合时，就可以从每一个键值对Entry对象中获取对应的key与value。
//返回set entrySet()返回所有entry对象
Set<Map.Entry<Integer, String>> entrys = map.entrySet();
for (Map.Entry<Integer, String> entry : entrys) {
System.out.println(entry.getKey() + "：" + entry.getValue());
}
HashTable 线程安全集合，运行速度比较慢 不允许存null key，null value
HashMap 线程不安全集合，运行速度快 可以存null key，null value
静态导入
import static XXX.YYY; 导入后YYY可直接使用
import static java.util.Map.Entry;
//for (Map.Entry<Student, String> entry : entrySet) {
for (Entry<Student, String> entry : entrySet) {
可变参数
前提：方法参数的数据类型需要确定，参数的个数不确定。
修饰符 返回值类型 方法名（参数类型… 参数名）
public static void main(String[] args) {
System.out.println(getSum(4,5,3,2,5,9));
}
public static int getSum(int... nums){
int sum = 0;
for(int i : nums){
sum+=i;
}
return sum;
}
一个方法中可变参数只能有一个， 如果有多个参数，可变参数要再参数列表最后一个。
Collections.sort 静态方法 对List集合升序排列
List<String> list = new ArrayList<String>();
list.add("sdf");
list.add("abc");
list.add("ccsl");
System.out.println(list); //[sdf, abc, ccsl]
Collections.sort(list);
System.out.println(list); //[abc, ccsl, sdf]
Exception 异常
如数组越界等，程序会为使用者抛出异常，停止程序。
throw关键字
抛出一个异常。
异常处理：
try{
可能出现异常的代码
}catch(异常类名 变量){
出现异常后执行的代码
}finally{
不管出现异常与否都执行的代码
}
int[] arrys = new int[]{1,2,3};
try{
int num = arrys[3];
System.out.println(num);
}catch (Exception ex){
System.out.println(ex);
}finally {
System.out.println("都会执行");
}