JAVA小白学习日记Day6

1.List

集合：把具有相同属性的东西放在一起，也可以是容器，把有关的东西都放进去。

List：List是位于java.util下的一个接口，有序集合（也称为序列）。此界面的用户可以精确控制每个元素在列表中的插入位置。用户可以通过整数索引（列表中的位置）访问元素，并在列表中搜索元素。

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

List的继承、实现关系：其继承了Collection接口并由AbstractList来实现，Collection又继承了Iterable接口。

List的种类：
ArrayList：底层由数组结构实现Object[]，可以存储任何Object类型的对象，是非线程安全的。
LinkedList：List和Deque接口的双向链表实现。实现所有可选列表操作，并允许所有元素（包括null ）。所有操作都按照双向链表的预期执行。索引到列表中的操作将从开头或结尾遍历列表，以更接近指定索引的为准。
Vector

ArrayList  扩容方式：
初始容量  10
扩容  1.5倍（右移一位，向下取整）

LinkedList  链表：
ArrayList和LinkedList性能比较
ArrayList是通过数组存储数据的，查找数据非常快
LinkedList查找速度慢，通过双向检索，优化检索速度
ArrayList插入和删除慢
LinkedList插入删除快

 List中方法的代码：

package com.easy719;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class EasyList {
    //容器  集合
    //之前学过的容器  数组
    //弊端：只能存储指定数据类型   数组的长度不可改变

    //List  Set  Map

    //List  接口
    //实现类：ArrayList   LinkedList   Vector
    public static void main(String[] args) {
        List list=new ArrayList();

        //List 中常用的方法
        //添加元素
        //各种类型都可，万物皆对象
        list.add("A");
        list.add(12);
        list.add(null);
        list.add(33.33);
        //获取元素
        Object obj=list.get(2);
        System.out.println(obj);//null
        System.out.println(list);//[A, 12, null, 33.33]
        //在指定位置插入元素  其他元素向后移
        list.add(1,44);
        list.add(5,"B");//可以是5但不能是6，否则越界
        System.out.println(list);//[A, 44, 12, null, 33.33, B]
        //设置元素
        list.set(2,22);
        System.out.println(list);//[A, 44, 22, null, 33.33, B]
        //是否包含某一个对象
        boolean bool=list.contains(22);
        System.out.println(bool);//true
        bool=list.indexOf(22)!=-1;
        System.out.println(bool);//true
        //判断是否包含另一个集合的所有元素
        List listA=new ArrayList();
        listA.add(33.33);
        listA.add(null);
        bool=list.containsAll(listA);
        System.out.println(bool);//true
        list.addAll(listA);
        System.out.println(list);//[A, 44, 22, null, 33.33, B, 33.33, null]
        list.add(listA);
        System.out.println(list);//[A, 44, 22, null, 33.33, B, 33.33, null, [33.33, null]]
        //删除元素
        //删除掉找到的第一个元素
        //参数传对象  删除这个对象  返回 Boolean
        //参数传下标  删除下标位置对象  返回被删除的对象

        list.add("A");
        System.out.println(list);//[A, 44, 22, null, 33.33, B, 33.33, null, [33.33, null], A]
        list.remove("A");
        System.out.println(list);//[44, 22, null, 33.33, B, 33.33, null, [33.33, null], A]
        //按下标删
        list.remove(2);
        System.out.println(list);//[44, 22, 33.33, B, 33.33, null, [33.33, null], A]
        //remove传入数字就是默认删除下标  加（Integer）
        list.remove((Integer)22);
        System.out.println(list);//[44, 33.33, B, 33.33, null, [33.33, null], A]
        bool=list.remove((Integer)22);
        System.out.println(bool);//true
        bool=list.remove((Integer)222);
        System.out.println(bool);//false
//        obj=list.remove("A");

        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());
        }
        //ArrayList  扩容方式
        //初始容量  10
        //扩容  1.5倍（右移一位，向下取整）


        for (Object item:list){
            if (item instanceof Double){
                if ((Double)item==33.33){
                    item=44.44;
                    System.out.println(item);
                }
            }
        }
/*        Object item;
        if (item instanceof List){
            List objs=(List) item;
            objs.set(1,"ABC");
        }
        */
        //LinkedList  链表
        //ArrayList和LinkedList性能比较
        //ArrayList是通过数组存储数据的，查找数据非常快
        //LinkedList查找速度慢，通过双向检索，优化检索速度

        //ArrayList插入和删除慢
        //LinkedList插入删除快
    }
}

2.内部类

可以将一个类的定义放在另一个类的内部，这就是内部类。我们一般将内部类分为四种：成员内部类、静态内部类、局部（方法内部类）、匿名内部类。

成员内部类总结：

内部类可以是任何的访问修饰符。
由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰符。
内部类的内部不能有静态信息。
内部类也是类，该继承的继承、该重写的重写、该重载的重载，this和super随便用。
外部类访问内部类的信息，必须先实例化内部类，然后 . 访问。
内部类可以直接使用外部类的任何信息，如果属性或者方法发生冲突（重名），使用Outer.this.成员
其他类访问内部类：
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在外部类的对象。

静态内部类总结：

静态内部类可以包含任意的信息，可以被任意访问权限修饰符修饰。
静态内部类的方法只能访问外部类的static关联的成员。
静态内部类可以独立存在，不依赖于其他外围类。
其他类访问内部类的静态信息，直接 Outer.Inner.static成员信息 就可以了。
其他类实例化内部类 Outer.Inner instance = new Outer.Inner();，然后 instance. 成员信息（属性、方法）即可。

局部内部类，定义在方法中，只能在方法中调用
不能用public，protected，private修饰，static也不行 

 内部类代码：

package com.easy719;

public class EasyInnerClass {
    public static void main(String[] args) {
        test();
    }
    //静态内部类
    public static class InnerA{

    }
    //成员(对象)内部类
    class InnerB{

    }
    //局部内部类，定义在方法中，只能在方法中调用
    //不能用public，protected，private修饰，static也不行
    public void inner(){
        class InnerC{

        }
        new InnerC();
    }
    public static void test(){
        InnerA a=new InnerA();
        new EasyInnerClass().new InnerB();
        //匿名内部类对象
        AbstractClass ac =new AbstractClass(){
          public void method(){}
        };
        AbstractClass aca =new AbstractClass(){
            public void method(){}
        };
        System.out.println(ac.getClass());
        System.out.println(ac.getClass()==aca.getClass());//false,两个对象不是同一个内部类，对象也不是同一个
        EasyInter ei=new EasyInter() {
            @Override
            public void method() {

            }
        };
        //lambda表达式
        EasyInter eia=()->{int aa=12;
            System.out.println("----------");};

        EasyInterA ea=()->12;
        //使用EasyInnerClass类中的fun方法代替EasyInter中未实现的方法
        EasyInter ee=EasyInnerClass::fun;
        ee.method();//function
    }
    public static void fun(){
        System.out.println("function");
    }
}
@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();
    }
}

3.块

代码块：又称为初始化块，属于类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，用 {} 包围起来。

（1）相当于另外一种形式的构造器（是对构造器的补充机制），可以做初始化操作；
（2）使用场景，如果多个构造器中都有重复的语句，可以抽取到代码块中，提高代码的复用性，相当于对构造器的重载；
（3）代码块调用的顺序优先于构造器。

1. 类什么时候被加载

（1）创建类的对象实例时（new），类会被加载。
（2）存在继承关系，当创建子类对象实例时，其所有上级父类也会被加载；并且父类先被加载，越上级的父类，越先被加载。
（3）当使用类的静态成员时（静态属性，静态方法），类会被加载。
（4）注意，类的加载是在内存的方法区中。

2. 什么是代码块

（1）static 关键字修饰的代码块也叫静态代码块，它的作用就是对类进行初始化；它伴随着类的加载而执行，并且只会执行一次。
（2）没有关键字修饰的代码块也叫普通代码块，它相当于是构造器的补充机制；每当我们创建一个类的对象时，普通代码块就会被调用一次；如果只是直接使用类的静态成员，没有创建对象，它不会被调用；注意，普通代码块的调用与类的加载没有关系。

代码：

package com.easy719;

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("子类---带参数的构造方法");
    }
}