1.容器类、集合类
之前学过的容器：数组，但是数组有局限：1.数组存储的数据类型有限制 2.数组存储的长度受限
2.容器类分为：List,Set,Map
3.List类：List是一个接口，他的实现类有：ArrayList,LinkedList,Vector
public static void main(String[] args) {
List list = new ArrayList();//创建一个ArrayList对象list
}4.List中常见的方法：（ArrayList中的存储是把各类型存放进数组中）
（1）add()：添加数据
public static void main(String[] args) {
List list = new ArrayList();
list.add("A");
list.add(12);
list.add(null);
list.add(33.33);
System.out.println(list);//[A,12,null,33.33]
}
（2）get()：获取某一项的数据
public static void main(String[] args) {
List list = new ArrayList();
list.add("A");
list.add(12);
list.add(null);
list.add(33.33);
System.out.println(list);//[A,12,null,33.33]
//获取指定元素 get
Object obj = list.get(2);
System.out.println(obj);//输出null（数组下标为2的项）
} （3）add还可以向指定位置插入元素
（4） set():修改数组中的元素值
public class EasyList {
public static void main(String[] args) {
List list = new ArrayList();
//List中常用的方法
//添加数据(可以存储任意类型) add
list.add("A");
list.add(12);
list.add(null);
list.add(33.33);
System.out.println(list);
//获取指定元素 get
Object obj = list.get(2);
System.out.println(obj);
//在指定位置插入元素 add
list.add(1,44);
System.out.println(list);//插入元素后，其他元素往后移
//list.add(6,"B");下标越界，因为不确定第五项的内容
list.add(5,"B");
System.out.println(list);//能插入第五项
//设置某一项的数据
list.set(2,22);//将下标为2的数据设置成22
System.out.println(list);//输出[A, 44, 22, null, 33.33, B]
}（5）contains():判断是否包含某个元素
boolean bool = list.contains(22);
System.out.println(bool);//包含22，布尔类型的变量bool为true（6） containsAll():判断是否多元素数组中的包含全部元素
List lista = new ArrayList();
lista.add(33.33);
lista.add(null);
bool = list.containsAll(lista);
System.out.println(bool);//true，list对象全部包含liata对象的元素[33.33,null]
System.out.println(lista);//[33.33,null]
lista.add(2);//将2添加到lista中
bool = list.containsAll(lista);//false，list中不含2
System.out.println(bool);//false（7）addAll():将全部元素依次添加到原容器对象中
list.add(lista);//添加一个元素，只不过这个元素是lista数组
System.out.println(list);
//[A, 44, 22, null, 33.33, B, [33.33, null, 2]]
list.addAll(lista);//添加多个元素，将lista中的元素都加入list
System.out.println(list);
//[A, 44, 22, null, 33.33, B, [33.33, null, 2], 33.33, null, 2]（8）remove()：删除元素
//删除元素（删除找到的第一个元素）
//参数传对象 删除这个对象 返回boolean
//参数传下标 删除下标位置的对象 返回被删除的对象
list.add("A");//[A,44, 22, null, 33.33, B, [33.33, null, 2], 33.33, null, 2, A]
list.remove("A");
System.out.println(list);//只会删除找到的第一个元素，第一个null
list.remove(2);//把下标为2删除掉，null被删除
System.out.println(list);
list.remove((Integer)22);
//加上(Integer)表示删除22这个元素,否则会自动识别成删除下标为22的元素（很容易下标越界）
//list.remove(22);//下标越界
System.out.println(list);
（9）size():获取数组中一共放有多少值（目前）
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}输出结果如下：依次输出每一项的值
第二种方式获取数组list的值：通过for循环遍历
for (Object item:list){
System.out.println(item);
}
//利用遍历的方式每次输出一个变量item（只是将list中每一项的值赋给变量item）第三种方式获取值：设置一个迭代器
Iterator it = list.iterator();//获取了一个迭代器(迭代器只能知道下一个元素是谁，以及有没有下一个元素)
while (it.hasNext()){//it.hasNext()判断还有没有下一个元素
System.out.println(it.next());//迭代出每一个元素
}//利用迭代器获取每一个元素注意：！！！！！！！！！！！！！！！！！！！！！！
for (Object item:list){
if (item instanceof Double){
if ((Double) item ==33.33){
System.out.println("item赋值"+item);
item = 99.99;
}
}
}
System.out.println(list);//只改变了输出的item的值，并不改变list的值这种方式只会修改变量item的值，真正list对象数组中的元素并不会发生改变
5.ArrayList和LinkedList的区别：
ArrayList （形式：数组）
初始容量：10 每次扩容扩1.5倍（自动扩容，最大值为21亿）
LinkedList （形式：链表） 实现了List接口
通过指向链表的方式存储数据，一个数据指向另一个数据，这样串联起来。
6.ArrayList和LinkedList性能的比较：
查找速度：
ArrayList是通过数组存储数据的，查找数据非常快
LinkedList是通过链表一项一项向后查找，查找速度慢（通过双向检索的方式优化检索速度）
插入、删除数据：
ArrayList插入和删除慢 （要保持有序和连贯）
LinkedList插入和删除快 （链表下一项只需要重新指向）（是双向链表，可以进行双向检索，从两边向中间检索，节省时间）
7.内部类和外部类：
下面代码中，Test类就是外部类（在类的外部），InnerA和InnerB是EasyInnerClass的内部类（在一个类的内部就叫做内部类）
public class EasyInnerClass {
//静态内部类 用的时候最多
public static class InnerA{}//是一个内部类（在EasyInnerClass类的内部），此时可以用protected/private修饰
//成员内部类 成员是对象
class InnerB{}//四个权限访问修饰符都可以修饰
}
class Test{
public static void method(){
EasyInnerClass.InnerA a = new EasyInnerClass.InnerA();
}
}//Test就是外部类（在类的外面）
//类只能是public或default修饰8.内部类
内部类分为静态内部类、成员内部类、局部内部类、匿名内部类
//静态内部类 用的时候最多
public static class InnerA{}//是一个内部类（在EasyInnerClass类的内部），此时可以用protected/private修饰
//成员内部类 成员是对象
class InnerB{}//四个权限访问修饰符都可以修饰
//局部内部类
public void inner(){//局部内部类在方法中写
class InnerC{}//局部内部类 只能用default修饰（public、protected、private都不行），也不能是静态的
}
//匿名内部类
//建立一个方法写匿名内部类
public static void test(){
InnerA a = new InnerA();
new EasyInnerClass().new InnerB();
AbstractClass ac = new AbstractClass(){//虽然抽象类不能实例化，但是语法上能写出来，只需要在类内部实现抽象方法，这里的{};就是类内部
@Override
public void method() {
}
};
AbstractClass aca = new AbstractClass(){//虽然抽象类不能实例化，但是语法上能写出来，只需要在内部实现抽象方法
@Override
public void method() {
System.out.println();
}
};
System.out.println(ac.getClass());//$1表示第一个匿名内部类
System.out.println(ac.getClass()==aca.getClass());
EasyInter ei = new EasyInter(){
@Override
public void method(){}
};//接口也有这种写法
EasyInter eia = ()->{int aa=12;
System.out.println("--------");};
eia=()-> System.out.println("111");//实现匿名内部类
EasyInterA ea=()->12;
//EasyInter ee = EasyInnerClass::fun;//使用EasyInnerClass::fun方法代替EasyInter中未执行的方法。
}
//写一个抽象类
abstract class AbstractClass{
public abstract void method();
}
9.代码块：
在类中，一个大括号（哪怕什么都不写，这也是一个代码块）
代码块在每一次创建对象时都会执行
public class EasyBlock {
//代码块：大括号{}
{
//成员代码块 每一次new对象的时候执行
System.out.println("这是成员代码块");
}
}10.静态代码块
static{
}
静态代码块在程序运行期间，只会执行一次（在成员代码块运行之前就运行）
public class EasyBlock {
static {//静态代码块 一个类的静态代码块在程序运行期间只会执行一次（在成员代码块之前运行）
//加载类对象时执行
System.out.println("父类----静态代码块");
}
}
11.子类继承父类时代码块的运行顺序：
1.父类静态代码块
2.子类静态代码块
3.父类的成员代码块
4.父类的构造方法
5.子类的成员代码块
6.子类的构造方法
public class EasyBlock {
{
//成员代码块 每一次new对象的时候执行
System.out.println("这是父类成员代码块");
}
static {//静态代码块 一个类的静态代码块在程序运行期间只会执行一次（在成员代码块之前运行）
//加载类对象时执行
System.out.println("父类----静态代码块");
}
EasyBlock(){
System.out.println("父类---构造方法");
}
public static void main(String[] args) {
new EasySon();
}
}
class EasySon extends EasyBlock {
{
System.out.println("这是子类成员代码块");
}
static {//静态代码块 一个类的静态代码块在程序运行期间只会执行一次（在成员代码块之前运行）
//加载类对象时执行
System.out.println("子类---------静态代码块");
}
EasySon(){
System.out.println("子类---构造方法");
}
}运行结果：
