Java学习Day6

List列表  

实现方法 arrayList  LinkList

在类中创建一个list对象：List list = new ArrayList();

List对象常用的方法

添加元素add（）方法

list.add("A");
list.add(12);
list.add(null);
list.add(333.33);
获取元素get（）方法
Object obj = list.get(2);
System.out.println(obj);
在指定位置插入元素,插入元素后面的其他元素向后移动
list.add(1, 44);//1是插入元素位置的下标，44是插入的元素
下标越界（类似于数组越界）当列表中只有五个元素时，向下表为6的位置插入元素就发生了数组越界。
list.add(6,11);
打印对象
System.out.println(list);
替换指定下标的元素set（）方法
list.set(2, 400);//前一个参数是要替换元素的位置下标，后一个参数是替换后的元素。
System.out.println(list);
是否包含某一个对象contain方法或indexOf方法
boolean bool = list.contains(400);
System.out.println(bool);
bool = list.indexOf(400) != -1;
System.out.println(bool);

可以向列表里添加浮点型元素，也可以添加空值null
List listA = new ArrayList();
listA.add(333.33);
listA.add(null);
判断是否包含另外一个列表中的所有元素containsAll（）方法
bool = list.containsAll(listA);
System.out.println(bool);
把集合中的所有元素添加到一个集合中addAll（）方法
list.addAll(listA);
System.out.println(list);
对列表直接使用add（）方法，把列表当做一个元素添加进list
list.add(listA);
System.out.println(list);
删除元素 删除掉找到的第一目标元素remove（）方法
参数传对象返回boolean类型，参数传下标，删除下标对象，返回被删除的对象
list.remove("A");
System.out.println(list);
删除指定下标的元素（参数超出列表元素范围可能会发生下标越界异常）
list.remove(2);
System.out.println(list);
删除数字元素
bool = list.remove((Integer) 44);
System.out.println(bool);
System.out.println(list);

遍历输出列表元素

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}
for (Object item : list) {
    System.out.println(item);
}
使用迭代器
Iterator it = list.iterator();//获取了一个迭代器
while (it.hasNext()) {
    System.out.println(it.next());
}

验证item对象是否为列表，如果是修改下标为1的元素为“ABC”

if (item instanceof List){
    List objs=(List)item;
    objs.set(1,"ABC");
}

ArrayList扩容方式  初始容量 10 以数组形式存储
扩容   原容量+原容量右移1位
LinkedList  链表  也是通过下标来找对象
ArrayList 是通过数组存储数据的，所以查找元素比较快
LinkedList 是通过链表结构 查找速度慢，使用双向链表通过双向检索的方式优化检索速度
ArrayList 插入和删除慢，LinkedList插入和删除快

内部类

静态内部类是使用 static 关键字修饰的内部类。它独立于外部类的实例，可以直接通过外部类的类名访问，也可以被其他类实例化。静态内部类可以访问外部类的静态成员和方法，但不能直接访问外部类的实例变量和非静态方法。

static class InnerA{ }

在测试方法中可以使用InnerA A = new InnerA();创建实例

成员内部类是没有 static 关键字修饰的内部类。它依赖于外部类的实例存在，可以访问外部类的所有成员变量和方法，包括私有的。成员内部类可以看作是外部类的一个成员，只有在创建了外部类的实例后，才能创建成员内部类的实例。

在EasyInnerClass类中的成员内部类InnerB创建实例

new EasyInnerClass().new InnerB();

局部内部类是定义在方法内部的类，它的作用域仅限于所在方法内部。局部内部类不能有访问修饰符和 static 关键字修饰，只能访问方法中的 final 局部变量，因为它们在方法调用后可能仍然存活。

public void inner(){
    //局部内部类（不能出方法，只能什么也不加修饰符）
    class InnerC{}
    new InnerC();
}

匿名内部类是没有名字的内部类，它通常用于创建只需使用一次的类的实例。匿名内部类通常用于实现接口或继承抽象类，并且可以在创建对象时直接实现其方法。

Lambda表达式

EasyInter eia = ()->{int aa=12;
System.out.println("-----");};
eia=()-> System.out.println("111111");
EasyInterA ea=()->{return 12;};
EasyInter ee = EasyInnerClass::fun;
ee.method();

代码块

静态代码块是使用 static 关键字修饰的代码块，它会在类被加载时执行，且只会执行一次，即使没有创建类的实例也会执行静态代码块。

static{
    //静态代码块 一个类的静态代码块只会执行一次
    //加载类对象时执行
    System.out.println("静态代码块");
}

成员代码块是定义在类中的普通代码块，没有使用 static 关键字修饰，它会在创建对象时被执行。每次创建对象时，都会执行一次成员代码块。

{//成员代码块，每一次new对象时执行
    //成员代码块在构造方法之前运行
    System.out.println("成员代码块");
}

当子类和父类同时拥有静态代码块，成员代码块，构造方法时，执行先后顺序为

1.父类静态代码块
2.子类静态代码块
3.父类的成员代码块
4.父类的构造方法
5.子类的成员代码块
6.子类的构造代码块

public class EasyBlock {
    static{
        //静态代码块 一个类的静态代码块只会执行一次
        //加载类对象时执行

        System.out.println("父类静态代码块");
    }
    {//成员代码块，每一次new对象时执行
        //成员代码块在构造方法之前运行
        System.out.println("父类成员代码块");
    }
    EasyBlock(){
        System.out.println("父类构造方法");
    }
    EasyBlock(int num){
        System.out.println("父类带参构造方法");
    }
    public static void main(String[] args){
        new EasySon();
     }
}
class EasySon extends EasyBlock{
    static{
        //静态代码块 一个类的静态代码块只会执行一次
        //加载类对象时执行

        System.out.println("静态代码块");
    }
    {//成员代码块，每一次new对象时执行
        //成员代码块在构造方法之前运行
        System.out.println("子类成员代码块");
    }
    EasySon(){
        System.out.println("子类构造方法");
    }
    EasySon(int num){
        System.out.println("子类带参构造方法");
    }
    public static void main(String[] args){
        new EasyBlock();
        new EasyBlock(12);
        System.out.println();
    }
}