java笔记day6

容器 集合

之前学过的容器 数组 它的弊端：只能存指定数据类型 数据长度不可改变

存储数据的方式：List Set Map

1，List 接口

实现类：ArrayList  LinkedList vector

List中常用的方法 ：

（1）添加元素

示例：

list.add("A");
list.add(12);
list.add(null);
list.add(33.33);
list.add("A");

（2）获取元素

往方法里面添加，去获取get

结合上面的代码续写：

 //获取元素
Object obj= list.get(2);//往方法里面添加去获取get
 System.out.println(obj);//null

（3）在指定位置插入元素，其他元素向后移

示例：

//在指定位置插入元素,其他元素向后移
        list.add(1,44);//往下标为1的位置插入44
        System.out.println(list);//[A, 44, 12, null, 33.33]

//        list.add(6,"C");//超出范围，下标越界
        list.add(5,"B");//往最后一个元素后面插入元素
        System.out.println(list);//[A, 44, 12, null, 33.33, B]

（4）设置替换元素

示例：

//设置替换元素
list.set(2,22);//设置下标为2的数据为44
System.out.println(list);//[A, 44, 22, null, 33.33, B]

（5）检查是否包含某一个对象（数据）

//检查是否包含某一个数据（对象）
boolean bool=list.contains(22);
System.out.println(bool);
bool=list.indexOf(22)!=1;
System.out.println(bool);

（6）检查一个集合是否包含另外一个集合中的所有元素

示例：

 List listA=new ArrayList();
        listA.add(33.33);
        listA.add(null);
//        listA.add(2);
        bool=list.containsAll(listA);
        System.out.println(bool);

（7）把一个集合中的所有元素添加到另一个集合中

示例：这里把listA的所有元素添加到list中

        list.addAll(listA);//[A, 44, 22, null, 33.33, B, 33.33, null]
      //list.add(listA);//[A, 44, 22, null, 33.33, B, A, [33.33, null]],添加一个对象元素
        System.out.println(list);
        System.out.println("=========");

（8）删除元素  （删除找到的第一个元素）

参数传对象 删除这个对象 返回boolean 

参数传下标 删除下表位置所在的那个对象  返回被删除的对象

传入的参数是数字，则删除该数字

示例：

list.remove("A");
System.out.println(list);

//删除指定下标的元素  传入数字就是下标
list.remove(2);

//如果要删除指定数字，需要
bool=list.remove((Integer)22);//删除下标返回对象
//删除对象返回bool值
System.out.println(bool);

（9）ArrayList扩容方式

初始容量是1.5  扩容 1.5倍

(10)LinkedList 和 ArrayList

LinkedList和ArrayList用法一样，存储数据的方式不一样

Linked采用链表

ArrayList用数组

/ArrayList和LinkedList性能比较
//ArrasyList是通过数组存储数据的 查找数据非常快
//LinkedList查找速度慢，通过双向检索方式优化检索速度

//ArrayList插入和删除慢  插入和删除数据相关数据需要后移或前移
// LinkedList查找和删除快

2.内部类  

静态内部类：

 

成员内部类：

局部内部类：

匿名内部类：

 

 

 

 

示例：

package com.easy719;

// 定义了一个公共类EasyInnerClass
public class EasyInnerClass {
    // 主方法，程序的入口点
    public static void main(String[] args) {
        // 调用静态方法test()
        test();
    }

    // 静态内部类InnerA，可以使用访问修饰符（public, protected, private, package-private）
    static class InnerA {
        // 静态内部类的具体实现细节
    }

    // 成员（非静态）内部类InnerB
    class InnerB {
        // 成员内部类的具体实现细节
    }

    // 一个方法inner()，在方法内部定义局部内部类
    public void inner() {
        // 定义局部内部类InnerC，注意局部内部类不能使用public等访问修饰符
        class InnerC {
            // 局部内部类的具体实现细节
        }
        // 创建局部内部类InnerC的一个实例
        new InnerC();
    }

    // 静态方法test()，用于演示内部类和接口的使用
    public static void test() {
        // 创建静态内部类InnerA的一个实例
        InnerA a = new InnerA();
        // 创建成员内部类InnerB的一个实例，需要先创建外部类的实例
        new EasyInnerClass().new InnerB();

        // 创建匿名内部类，实现AbstractClass接口
        AbstractClass ac = new AbstractClass() {
            // 实现AbstractClass的抽象方法method()
            public void method() {
                // 实现细节
            }
        };
        // 创建另一个匿名内部类实例
        AbstractClass aca = new AbstractClass() {
            // 实现AbstractClass的抽象方法method()
            public void method() {
                // 实现细节
            }
        };

        // 输出ac的类信息
        System.out.println(ac.getClass());
        // 检查ac和aca是否属于同一个类（匿名内部类每次创建都是不同的类）
        System.out.println(ac.getClass() == aca.getClass());

        // 创建EasyInter接口的匿名内部类实例
        EasyInter ei = new EasyInter() {
            @Override
            public void method() {
                // 实现EasyInter接口的抽象方法method()
            }
        };

        // 使用Lambda表达式简化匿名内部类的创建
        // Lambda表达式用于实现只有一个抽象方法的接口（函数式接口）
        EasyInter eia = () -> {
            int aa = 12;
            System.out.println("------");
        };
        // Lambda表达式的另一种写法
        eia = () -> System.out.println("11111");

        // 使用Lambda表达式创建EasyInterA接口的实例，该接口的method()方法有返回值
        EasyInterA ea = () -> 12;

        // 使用方法引用创建EasyInter接口的实例，引用EasyInnerClass类的静态方法fun()
        EasyInter ee = EasyInnerClass::fun;
        // 调用ee的method()方法，实际上调用的是EasyInnerClass的fun()方法
        ee.method();
    }

    // 定义一个静态方法fun()
    public static void fun() {
        // 方法体
        System.out.println("function");
    }
}

// 定义了一个函数式接口EasyInter，用于声明只有一个抽象方法的接口
@FunctionalInterface
interface EasyInter {
    // 声明一个没有实现的抽象方法method()
    void method();
}

// 定义了一个接口EasyInterA，用于声明有返回值的抽象方法
interface EasyInterA {
    // 声明一个没有实现的抽象方法method()
    int method();
}

// 定义了一个抽象类AbstractClass，包含一个抽象方法method()
abstract class AbstractClass {
    // 抽象方法没有方法体，不能直接new一个AbstractClass的实例
    public abstract void method();
}

// 定义了一个类Test，用于演示如何在外部类中使用内部类
class Test {
    // 定义一个静态方法method()，在方法中创建EasyInnerClass的静态内部类InnerA的实例
    public static void method() {
        EasyInnerClass.InnerA a = new EasyInnerClass.InnerA();
    }
}

3.代码块

（1）静态代码块  一个类的静态代码块在程序运行时只会执行一次（加载类对象的时候执行）

static {
    //静态代码块  一个类的静态代码块在程序运行时只会执行一次
    //加载类对象的时候执行
    System.out.println("静态代码块");
    //先有类再有对象，运行时先执行类
    //子父类：先执行父类再执行子类
}

运行顺序：1，（先有类再有对象，运行时先执行类，再执行对象）

2，（子父类之间：先执行父类再执行子类）

（2）成员代码块  直接写大括号“  {  }   ”叫做成员代码块

在每一次实例化对象的时候执行  成员代码块在构造方法之前执行

{
    //直接写大括号叫做成员代码块
    //在每一次实例化(new)对象的时候执行

    //成员代码块在构造方法之前运行
    System.out.println("成员代码块");
}

（3）构造方法

EasyBlock(){//构造方法  方法名和类名一样

    System.out.println("构造方法");
}

（4）子类和父类运行顺序

 public static void main(String[] args) {
//        new EasyBlock();
//        new EasyBlock(12);
        new EasySon();
        //1.父类静态代码块
        //2.子类静态代码块
        //3.父类成员代码块（在构造方法之前）
        //父类的构造方法
        //5.子类成员代码块
        //6.子类构造方法
    }