1.List集合
list容器（集合）
之前学过的集合是数组，但是数组只能存储一种类型的数据，而且一旦声明长度之后不能更改，只能建立一个新的数组，所以为了解决这个弊端建立了list
list 接口 有三个实现类：ArrayList LinkList Vector
1.添加元素 add
添加的数据如果不加"",例如直接添加12，那么存入的类型就是int类型
list.add("a");
list.add(12+13);
list.add(null);
list.add(33.33);
System.out.println(list); //[a, 25, null, 33.33]2.获取元素 get
Object obj=list.get(2);
System.out.println(obj);//null3.在指定位置插入元素 add
list.add(1,44); //在1位置添加44，原本1位置和后边数据往后移
System.out.println(list); //[a, 44, 25, null, 33.33]
list.add(5,54); //上面的list长度是5所以最大只能在5的位置插入数
//list.add(9,54); 下标越界
System.out.println(list); //[a, 44, 25, null, 33.33, 54]4.设定元素 set
list.set(2,22);
System.out.println(list);
//原本2位置的数换成了22，其他位置的数不变[a, 44, 22, null, 33.33, 54]5.包含元素 contains/containsAll
boolean b=list.contains(22);
System.out.println(b); //true
b=list.indexOf(22)!=-1;
System.out.println(b); //true
List list1=new ArrayList();
list1.add(33.33);
list1.add(null);
b=list.containsAll(list1); //判断是否包含另一个集合中所有元素
System.out.println(b+"------"); //true6.将list1数组中的数全部添加到list中 addAll
System.out.println(list); //[a, 44, 22, null, 33.33, 54]
System.out.println(list1); //[33.33, null]
list.addAll(list1);
System.out.println(list); //[a, 44, 22, null, 33.33, 54, 33.33, null]7.删除元素 remove
参数传对象，删除这个对象，返回boolean
参数传下标 删除这个下标的对象 返回这个对象
obj=list.remove(null);
System.out.println(obj); //true
System.out.println(list);//[a, 44, 22, 33.33, 54, 33.33, null],只会删除第一个符合的元素8.删除下标 remove
System.out.println(list); //[a, 44, 22, 33.33, 54, 33.33, null]
obj=list.remove(2);
System.out.println(list); //[a, 44, 33.33, 54, 33.33, null]
System.out.println(obj+"====="); //删除下标为2的位置的数据返回被删除的数据：229.长度 length
长度方法一般用在循环
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//结果：
// a
// 33.33
// 54
// 33.33
// null
另一种循环遍历方式
此外循环遍历数组还可以用下面的方法
for (Object item:list){
System.out.println(item);
}两个方法输出结果一致
10.下标 index
b=list.indexOf(22)!=-1;
System.out.println(list); //[a, 44, 22, null, 33.33, 54]
System.out.println(b+"------"); //true
System.out.println(list.indexOf(22)); //输出的是下标2
11.ArrayList和LinkedList
ArrayList的默认容量是10，如果容量不够会自动扩容每次扩容都是向右移位+原容量
所以第一次扩容之后是15，第二次扩容之后是22
1.LinkedList和Arraylist用法一样，但是存储数据的接口不一样
2.LinkedList 是以链表的方式
3.最大值和ArrayList一样
12.迭代器
//迭代器
Iterator is=list.iterator();//获取了一个迭代器 迭代器只能知道下一个元素是谁，有没有下一个元素
//适合不知道有多少个元素的时候
while (is.hasNext()){//hasNext()判断是否有下一个1
System.out.println(is.next());
}2.代码块
1.代码块
1.成员代码块：
成员代码块 每一次new对象的时候执行,而且在构造方法之前运行
{
//成员代码块 每一次new对象的时候执行,而且在构造方法之前运行
System.out.println("父类---成员代码块");
}2.静态代码块
静态代码块： 一个类的静态代码块在程序运行期间只会执行一次（在加载类对象的时候执行），比成员代码块执行还要早
static {
System.out.println("父类---静态代码块");
}public class EasyBlock {
{
//成员代码块 每一次new对象的时候执行,而且在构造方法之前运行
System.out.println("父类---成员代码块");
}
EasyBlock(){
System.out.println("父类---构造方法");
}
EasyBlock(int a){
System.out.println("父类---构造方法");
}
public static void main(String[] args) {
new EasyBlock2();
//先是父类的静态代码块，然后是子类的静态代码快，父类成员代码块，父类构造方法，子类成员代码块，子类构造方法
}
//静态代码块 一个类的静态代码块在程序运行期间只会执行一次（在加载类对象的时候执行），比成员代码块执行还要早
//如果父类和子类同时执行静态代码块的时候，先执行父类的
static {
System.out.println("父类---静态代码块");
}
}
class EasyBlock2 extends EasyBlock {
{
//成员代码块 每一次new对象的时候执行,而且在构造方法之前运行
System.out.println("子类----成员代码块");
}
EasyBlock2(){
System.out.println("子类----构造方法");
}
EasyBlock2(int a){
System.out.println("子类----参数构造方法");
}
//如果父类和子类同时执行静态代码块的时候，先执行父类的
static {
System.out.println("子类---静态代码块");
}
}
结果：
父类---静态代码块
子类---静态代码块
父类---成员代码块
父类---构造方法
子类----成员代码块
子类----构造方法
3.内部类
1.成员内部类
需要对象来调用 用的比较少
2.静态内部类
用static修饰，而且四个访问权限修饰符
3.匿名内部类
4.局部内部类
在方法中建一个类
public class EasyClass {
public static void main(String[] args) {
test9();
}
//外部类：独立的类
//内部类：在类内部就是内部类
//声明类的时候只能用public default
//静态内部类 用的比较多
static class InnerA {//EasyClass的内部类
//访问权限修饰符四个都可以用
}
public static void test() {
InnerA innerA = new InnerA();
}
//成员（对象）内部类//需要对象来调用 用的比较少
//访问权限修饰符四个都可以用
class InnerB {//没有static修饰
}
public static void test1() {
new EasyClass().new InnerB();
}
//局部内部类，在方法中建一个类 用的很少
//不能用public，private protected 只能什么也不加 使用static都不可以
public void inner() {
class InnerC {//语法通过，
}
}
public static void test9() {
//匿名内部类对象
AbstractClass ac = new AbstractClass(){//现在已经有了一个对象，但不是AbstractClass类
@Override
public void method() { //会重写下面的抽象类中的method方法
System.out.println("df");
}
};
System.out.println(ac.getClass());
AbstractClass aca = new AbstractClass() {//现在已经有了一个对象，但是不是 AbstractClass类，系统会主动加载（生成一个类）
@Override
public void method() {
System.out.println("df");
}
};
System.out.println(aca.getClass());
System.out.println(ac.getClass()==aca.getClass());//false
EasyInter ei=new EasyInter() {
@Override
public void method() {
}
};
//下面的接口代码是上面的简化
EasyInter eia=()->{//多行代码的时候用{} 一行代码就可以直接写
int a=12;
System.out.println(a);
};
EasyInterA eA=()->12;//12就是返回值 //如果有多行代码也可以用{}
EasyInter ee=EasyClass::fun;
ee.method();//这个就是实现下面的fun方法
}
public static void fun(){
System.out.println("fun");
}
}
@FunctionalInterface
interface EasyInter{
void method();
}
interface EasyInterA{
int method();//需要一个返回值
}
abstract class AbstractClass{
public abstract void method();
}
class Test{
public void method(){
EasyClass.InnerA innerA=new EasyClass.InnerA();
}
}