Java学习笔记6

今日内容:

List     ArrayList 扩容机制 LinkedList 双向检索   
内部类  静态内部类 成员内部类 局部内部类 匿名内部类(对象) 
代码块  成员代码块  静态代码块  执行顺序

List

数组弊端：只能存指定数据类型  数组长度不可改变

集合类型有 List Map Set

List的接口

实现类：ArrayList  LinkedList  Vector

List 中常用的方法

1.添加元素

（1）单个添加元素

list.add("A");

list.add(12);

list.add(null);

list.add(33.33);

（2）将一个类中的集合添加到另外一个集合

list.addAll(listA);//把所有元素依次添加

System.out.println(list);

System.out.println("----------------------");

list.add(listA);//把所有元素当成一个元素添加的里面

System.out.println(list);

System.out.println("----------------------");

2.获取元素

Object obj = list.get(2);

System.out.println(list.get(2));



System.out.println(list);

3.指定位置插入元素，其他元素后移

list.add(1, 44);

list.add(5, "bc");//可以在最后插入列入现在有5个元素可以在，下标为5的地方插入但是不能越界在下标为6的地方插入

4.改变元素

.set(下标，要改成的数据);

list.set(2, 22);

System.out.println(list);

5.查找元素

1.是否存在 可以用.contains/.indexOf

boolean bool = list.contains(22);

System.out.println(bool);

bool = list.indexOf(22) != -1;

System.out.println(bool);

2.查找一个集合是否包含另一个集合中的所有元素

 List listA = new ArrayList();

  listA.add(33.33);

  listA.add(null);

  listA.add(2);

  bool = list.contains(listA);

    System.out.println(bool);

6.删除元素

list.remove("A");//只删除找到的第一个元素

//想要删除全部“A”用while循环

//删除下标所在位置的元素

list.remove(2);

//remove删除下标时的返回值是下标对应的对象本身 若要删除的下标越界则返回错误，删除对象时返回值是boolean

        

笔试题

list.remove(22);//传入数字就是删除下标

list.remove((Integer) 22);//加入Integer将数字强行转化，会删除22

ArraList 的扩容方式

初始容量是  10

每次扩容 1.5倍

ArrayList：

基于动态数组实现，允许访问任意位置的元素。

在添加或删除元素时，可能需要调整数组的大小。

提供了快速的随机访问能力。

LinkedList：

基于双向链表实现，允许高效的插入和删除操作。

每个元素都是一个节点，包含数据和指向前一个和后一个节点的指针。

相对于ArrayList，随机访问的速度较慢。

内部类

静态内部类

  

  public static class InnerA {

    }

成员(对象)内部类

 

   class InnerB {

    }

局部内部类,定义在方法中，不能用修饰符修饰        

public void inner() {
      class InnerC {



        }

    }



    public static  void test() {

        InnerA a = new InnerA();

        new EasyInnerClass().new InnerB();

匿名内部类对象

      

  AbstractClass ac = new AbstractClass() {

            @Override

            public void method() {



            }

        };

        AbstractClass aca = new AbstractClass() {

            public void method() {



            }

        };

        System.out.println(ac.getClass());

        System.out.println(aca.getClass() == ac.getClass());

        EasyInter ei = new EasyInter() {

            @Override

            public void method() {



            }

        };

        EasyInter eia = () -> {

            int aa = 12;

            System.out.println("-------------");

        };

        eia = () -> System.out.println("11111");



        EasyInterA ea = () -> 12;

        EasyInter ee = EasyInnerClass::fun;

        ee.method();

    }


    public static void fun() {

    }

}



@FunctionalInterface

interface EasyInter {

    void method();

}



@FunctionalInterface

interface EasyInterA{

    int method();

}

abstract class AbstractClass {

    public abstract void method();

}



class Test {

    public static void method() {

        EasyInnerClass.InnerA a = new EasyInnerClass.InnerA();

    }

}

代码块

静态代码块，一个类的静态代码块只会执行一次，会在加载类对象时执行

成员代码块，每一次new对象时执行，在构造方法之前执行

执行顺序

1.父类静态代码块

2.子类静态代码块

3.父类的成员代码块

4.父类的构造方法

5.子类的成员代码块

6.子类的构造方法

public class EasyBlock {

    static {

         System.out.println("父类--静态代码块");

    }



    {

         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("子类---静态代码块");

    }



    {

        System.out.println("子类---成员代码块");

    }



    EasySon() {

        System.out.println("子类---构造方法");

    }



    EasySon(int num) {

        System.out.println("子类---带参数构造方法");

    }



}