面向对象编程：集合

集合

1、ArrayList保存一组有序对象

---

import java.util.ArrayList;
class Student {
    public int stuId; // 学号
    public String name;
}
class Teacher {
    public int workId; // 工号
    public String name;
}
public class Test3 {
    public static void main(String[] args) {
        // 定义一个集合对象， 我们使用ArrayList
        ArrayList list = new ArrayList();
        list.add("陈永仁");
        list.add("刘建明"); // 编写顺序来存的
        list.add(999);
        list.add(new Student());
        list.add(new Teacher());
        // 为什么出现 【】
        System.out.println(list.toString());
        // 很多API
        int size = list.size(); // 获取集合里面装了多少个数据
        System.out.println("个数：" + size);
        // 获取集合中的某个数据  -> 向上转型
        Object o = list.get(1);
        System.out.println(o);
        // 判断某个对象在集合中是否存在
        boolean r = list.contains("陈永仁");
        System.out.println(r);
        // 获取某个对象的索引下标 ，如果没有的化就是-1
        int index = list.indexOf("刘建明");
        System.out.println(index);
        // 把999替换为吕布
        list.set(2 , "吕布");
        System.out.println(list.toString());
        // 移除某个元素
        list.remove("刘建明");
        System.out.println(list.toString());
        // 直接清空集合
        list.clear();
        System.out.println(list.toString());
        // **********************怎么来遍历集合**************************
    }
}

2、遍历集合的8种方式

class Student {
    public int stuId; // 学号
    public String name;
}
class Teacher {
    public int workId; // 工号
    public String name;
}
public class Test4 {
    public static void main(String[] args) {
        // 定义一个集合对象， 我们使用ArrayList
        ArrayList list = new ArrayList();
        list.add("陈永仁");
        list.add("刘建明"); // 编写顺序来存的
        list.add(new Student());
        list.add(new Teacher());
        // **********************怎么来遍历集合**************************
        // 方式1： fori
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("---------------------------");
        // 方法2：for-each
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("----------------------------");
        //方式3 ： 通过迭代器对象来完成 (用的不是特别多)
        Iterator iterator = list.iterator(); // 获取一个迭代器对象
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    /*    System.out.println(iterator.next()); // 移动指针往下，获取到了第一个元素！！
        System.out.println(iterator.next()); // 再往下
        System.out.println(iterator.next()); // 再往下
        System.out.println(iterator.next()); // 再往下  最后了*/
        System.out.println("*************************************");
        // 方式4：jdk8 Lambda
        // 要传一个参数，类型为Consumer ， 但是我们通过查看源码，发现它居然是一个接口
        // 早上讲到了- 》如果接口只有1个方法，创建实现类不方便，我们可以创建一个匿名内部类
        // 能看懂的Q1
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
        // oracle 官方人员没事做了，加了一些语法糖而已
        // 通过Lambda表达式来简化  ， 1级简化
        list.forEach((Object o) -> {
            System.out.println(o);
        });
        // 通过Lambda表达式来简化 - > 再简化 2级简化
        list.forEach((o) -> {
            System.out.println(o);
        });
        // 通过Lambda表达式来简化 - > 再简化 3级简化
        list.forEach((o) -> System.out.println(o) );
        // 通过Lambda表达式来简化 - > 再简化 4 级简化 (终极形态)
        // ::  引用操作符  println拿过来当作匿名实现类
        list.forEach(System.out::println);
        // 8种方式遍历集合  -
    }
}

3、、HashSet保存一组无序对象

4、TreeSet一组对象排序

5、HashMp保存一行字典数据

6、Iterator迭代器内存原理

​ 首先创建一个迭代器对象，通过指针向下移动访问集合每个元素

​ 主要的方法有 ： next（） ， hasNext();

7、类型安全的集合【给集合添加类型限定】

/**
 * 类型安全的容器
 */
public class Test7 {
    public static void main(String[] args) {
        //   List<Student>  -> 泛型
        // 人家数组都可以限定类型
        Student[] stus = {};
        // list3就是一个类型安全的容器 - 》 不用你去操心， 编译器它就知道list3里面存储的全部都是String类型的对象
        List<Student> list3 = new ArrayList();
        list3.add(new Student());
        list3.add(new Student());
        list3.add(new Student());
        // ------------------遍历集合，打印学生信息
        for (Student student : list3) {
            System.out.println(student.name);
            System.out.println(student.stuId);
        }
    }
}

8、外部比较器Comparator

9、匿名内部类

// 这个接口只有一个方法.......
interface Phone {
    public void call(); // 打电话
}
class  XiaoMi implements  Phone {
    @Override
    public void call() {
        System.out.println("小米手机正在打电话。。。");
    }
}
abstract class Pet {
    public abstract void eat();
}
public class Test {
    public static void main(String[] args) {
        // *****站在知识体系来说：匿名【内部】类
        // 简单：所谓的内部类，就是定义在方法里面的， 或定义再类里面的类
        // 抽象抽象类的对象，也是通过匿名实现类来完成的
        Pet p = new Pet() {
            @Override
            public void eat() {
                System.out.println("吃东西了!!!!!");
            }
        };
        p.eat();
        // 把实现类整个拷贝了过来
        // 把类名去掉了 - 》 没有类名  - > 没有类名的实现类  -》 （匿名的） - > 匿名实现类
        // 语法：
        //  1、匿名实现类必须放到方法里面来！！！
        //  2、把类名去掉
        //  3、创建匿名实现类的对象， 必须new关键字一起出现
        //  new Phone()  .. 告诉编译器你等一下 ，我还没写 。。。
        Phone phone = new Phone() {
            @Override
            public void call() {
                System.out.println("小米手机正在打电话......");
            }
        };
        phone.call();
    }
}

10、Lambda简化匿名实现类

参考遍历集合的那几种方式

11、数组扩容方案

import java.util.Arrays;
public class Test2 {
    public static void main(String[] args) {
        /*数组存部下的临时解决方案*/
        // 我定义了一个数组，长度为2 . 只能存两个数据！！
        String[] names = new String[2];
        names[0] = "陈永仁";
        names[1] = "刘建明";
        // 第三个人吕布该怎么存？？ names数组长度已经固定了！！
        // 重新创建一个数组长度为3，然后把内容拷贝过去
        String[] newNames =  Arrays.copyOf(names , 3);
        System.out.println(Arrays.toString(newNames));
    }
}

12、instanceof关键字【可以判断某个对象运行时的类型】

​ 语法： if(对象名 instanceof 类名) {

​ }