java学习笔记第六天-CSDN博客

本文链接：https://blog.csdn.net/Word_seeker/article/details/140557419

集合是容器
之前学过的数组也是容器，但是数组有弊端：只能存指定数据类型，数组长度不可改变
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);
Syetem.out.println("list");//[A, 12, null, 33.33]

获取元素

        Object obj=list.get(2);//下标为2
        System.out.println(obj);//null

在指定位置插入元素

list.add(1,44);//[A, 44, 12, null, 33.33]
list.add(5,"B");//可以在数组最大下标+1处插入，
System.out.println(list);//[A, 44, 12, null, 33.33, B]

更改指定位置元素

list.set(2,50);
System.out.println(list);//[A, 44, 50, null, 33.33, B]

查看是否包含某一个对象
indexOf方法用来查找对象第一次出现的下标位置，找不到返回-1，所以，不返回-1就代表能查找到某一个对象

boolean bool=list.contains(44);
System.out.println(bool);//true

bool=list.indexOf(50)!=-1;
System.out.println(bool);//true

检查一个集合内是否包含另一个集合中所有元素

List listA=new ArrayList();
listA.add(33.33);//[33.33]
listA.add(null);//[33.33,null]
bool=list.containsAll(listA);//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]]

删除元素(只删除找到的第一个元素)

list.remove(33.33);
System.out.println(list);
//[A, 44, 22, null, B, 33.33, null, [33.33, null]]

参数传对象删除这个对象返回布尔值
参数传下标删除下标位置对象返回被删除的对象

obj=list.remove(33.33);//参数传对象
System.out.println(obj);//true

//obj=list.remove(0);//参数传下标
//System.out.println(obj);//A，删除A

删除下标所代表的元素

list.remove(2);
System.out.println(list);
//[A, 44, null, B, null, [33.33, null]]

指定元素删除

list.remove((Integer)44);
System.out.println(list);
//[A, null, B, null, [33.33, null]]

获取集合元素并打印，下标法，仅限于明确知道集合内元素类型的情况下

        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
/*A
null
B
null
[33.33, null]*/

不知集合内数据类型，可以用Object

        for(Object item:list){//遍历集合
            System.out.println(item);
        }
/*A
null
B
null
[33.33, null]*/

不知道集合内数据类型和数据个数的时候

        Iterator it=list.iterator();//获取了一个迭代器
        while(it.hasNext()){
            System.out.println(it.next());
        }
/*A
null
B
null
[33.33, null]*/

清空集合元素

        while(!list.isEmpty()){//如果list不为空
            list.remove(0);//一直删除第一个元素
        }//元素全删

ArrayList 扩容方式
初始（默认）容量：10
每一次扩容都扩大到原来的1.5倍

更改大集合中的小集合的元素

System.out.println(list);
    //[A, null, B, null, [33.33, null]]
for(Object item:list){//遍历大集合
    if(item instanceof List){//类型检查，检查是否是集合
    	List objs=(List)item;
        objs.set(1,"ABC");//将大集合中的小集合的元素更改
    }
	System.out.println(list);
	//[A, null, B, null, [33.33, ABC]]
}

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

ArrayList查找快，插入和删除慢，要保持有序连贯
LinkedList插入和删除快

独立的类叫外部类，写在类内的叫内部类

package com.easy719;

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

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

    public void Inner(){
        //局部内部类
        class InnerC{}
        new 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() {
            @Override
            public void method() {
                System.out.println();
            }
        };
        System.out.println(ac.getClass());
        //class com.easy719.EasyInnerClass$1
        System.out.println(aca.getClass()==ac.getClass());
        //false
        //外部类
class Test{
    public static void method(){
        EasyInnerClass.InnerA a=new EasyInnerClass.InnerA();
        //外部类调用其他类内的声明的内部类
    }
}
@FunctionalInterface
interface EasyInter{
    void method();
}
interface EasyInterA{
    int method();
}

abstract class AbstractClass{
    public abstract void method();
}

lambda表达式初写
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

parameters 是参数列表，expression 或 { statements; } 是Lambda 表达式的主体。如果只有一个参数，可以省略括号；如果没有参数，也需要空括号。

        EasyInter ei=new EasyInter() {
            @Override
            public void method() {}
        };
        EasyInter eia=()->{int aa=12;
            System.out.println();};
        eia=()-> System.out.println("111");

        EasyInterA ea=()->{return 12;};
        EasyInter ee=EasyInnerClass::fun;
        ee.method();//function
    }
    public static void fun(){
    	System.out.println("function");
    }
}

静态代码块一个类的静态代码块在程序运行期间只会执行一次
加载类对象时执行

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

如果一个子类继承一个父类，父类内有静态代码块，成员代码块，构造方法和带参数的构造方法，则子父类的各部分运行结果如下：
1.父类静态代码块
2.子类静态代码块
3.父类的成员代码块
4.父类的构造方法
5.子类的成员代码块
6.子类构造方法

package com.easy719;

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();
        //1.父类静态代码块
        //2.子类静态代码块
        //3.父类成员代码块
        //4.父类构造方法
        //5.子类成员代码块
        //6.子类构造方法
    }
}

 class EasySon extends EasyBlock {
     static {
         System.out.println("子类静态代码块");
     }

     {
         System.out.println("子类成员代码块");
     }
     EasySon() {
         System.out.println("子类构造方法");
     }

     EasySon(int num) {
         System.out.println("带参数的构造方法");
     }
 }