Java--集合--Collection

1. 集合

1.1. 什么是集合

存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。
集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。

1.2. 集合和数组的区别

数组和集合类都是容器
数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。
集合类的特点
用于存储对象，长度是可变的，可以存储不同类型的对象。

1.2.1. 数组的缺点
存储类型单一的数据容器，操作复杂(数组一旦声明好不可变)CRUD

1.3. 集合的分类

集合做什么
1：将对象添加到集合
2：从集合中删除对象
3: 从集合中查找一个对象
4：从集合中修改一个对象
就是增删改查
注意：集合和数组中存放的都是对象的引用而非对象本身

Java工程师对不同的容器进行了定义,虽然容器不同,但是还是有一些共性可以抽取最后抽取了一个顶层接口,那么就形成了一个集合框架。如何学习呢?当然是从顶层学起,顶层里边具有最共性,最基本的行为。具体的使用,就要选择具体的容器了。为什么? 因为不断向上抽取的东西有可能是不能创建对象的.抽象的可能性很大，并且子类对象的方法更多一些. 所以是看顶层,创建底层。那么集合的顶层是什么呢 叫做Collection集合框架体系

为什么出现这么多集合容器，因为每一个容器对数据的存储方式不同，这种存储方式称之为数据结构（data structure）
注意 集合和数组中存放的都是对象的引用。

2. 集合类(Collection)

Collection接口有两个子接口：
————–List(链表|线性表)
—————Set(集)
特点：
Collection中描述的是集合共有的功能(CRUD)
——List可存放重复元素，元素存取是有序的
——Set不可以存放重复元素，元素存取是无序的

java.util.Collection
        ---| Collection     描述所有接口的共性
            ----| List接口    可以有重复元素的集合
            ----| Set  接口   不可以有重复元素的集合

2.1. Collection接口的共性方法

增加：
1：add() 将指定对象存储到容器中
add 方法的参数类型是Object 便于接收任意对象
2：addAll() 将指定集合中的元素添加到调用该方法和集合中
删除：
3：remove() 将指定的对象从集合中删除
4：removeAll() 将指定集合中的元素删除
修改
5：clear() 清空集合中的所有元素
判断
6：isEmpty() 判断集合是否为空
7：contains() 判断集合何中是否包含指定对象（内部依赖于使用equals()判断两个对象是否相等 ）
8：containsAll() 判断集合中是否包含指定集合
获取:
9：int size() 返回集合容器的大小
迭代
10： toArray() 集合转换数组，存到一个object的数组返回，object [ ]；
11：iterator()返回在此collection的元素上进行迭代的迭代器

2.1.1. 增加：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        System.out.println(list);
        // [计算机网络, 现代操作系统, java编程思想]

// 增加2 将list容器元素添加到list2容器中
        Collection list2 = new ArrayList();
        list2.add("java核心技术");
        list2.addAll(list);
        list2.add("java语言程序设计");
        System.out.println(list2);
        // [java核心技术, 计算机网络, 现代操作系统, java编程思想, java语言程序设计]
    }

2.1.2. 删除：

// 删除1 remove
        boolean remove = list2.remove("java核心技术");
        System.out.println(remove); // true
        System.out.println(list2); //
        //删除2 removeAll() 将list中的元素删除
        boolean removeAll = list2.removeAll(list);
        System.out.println(removeAll);//true
        System.out.println(list2);//[java语言程序设计]

2.1.3. 修改：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 修改 clear() 清空集合中的所有元素
        list.clear();
        System.out.println(list); //[] 
    }

2.1.4. 判断：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);

        boolean empty = list.isEmpty();
        System.out.println(empty);// false
        boolean contains = list.contains("java编程思想");
        System.out.println(contains);// true
        Collection list2 = new ArrayList();
        list2.add("水许传");
        boolean containsAll = list.containsAll(list2);
        System.out.println(containsAll);// false

    }

2.1.5. 获取：

public static void main(String[] args) {
        Collection list = new ArrayList();
        // 增加：add() 将指定对象存储到容器中
        list.add("计算机网络");
        list.add("现代操作系统");
        list.add("java编程思想");
        list.add("java核心技术");
        list.add("java语言程序设计");
        System.out.println(list);
        // 获取  集合容器的大小 
        int size = list.size();
        System.out.println(size); 
    }

2.1.6. 练习：集合中添加自定义对象
该案例要求完成使用集合:

public static void main(String[] args) {

        // 创建集合对象
        Collection coll = new ArrayList();

        // 创建Person对象
        Person p1 = new Person("jack", 25);
        Person p2 = new Person("rose", 22);
        Person p3 = new Person("lucy", 20);
        Person p4 = new Person("jack", 25);

        // 集合中添加一些Perosn

        // 删除指定Person

        // 删除所有Person

        // 判断容器中是否还有Person

        // 判断容器中是否包含指定Person

        // 获取容器中Person的个数

        // 将容器变为数组,遍历除所有Person

    }

分析:
Person类
—-：姓名和年龄
—-：重写hashCode和equals方法
———：如果不重写，调用Object类的equals方法，判断内存地址，为false
—————–：如果是Person类对象，并且姓名和年龄相同就返回true
———：如果不重写，调用父类hashCode方法
—————–：如果equals方法相同，那么hashCode也要相同，需要重写hashCode方法
———：重写toString方法
—————–：不重写，直接调用Object类的toString方法，打印该对象的内存地址

Person类

class Person {
    private String name;
    private int age;
public Person() {
}

public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

@Override
    public int hashCode() {
        return this.name.hashCode() + age;
    }

@Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;
        return this.name.equals(p.name) && this.age == p.age;
    }

@Override  
    public String toString() {
        return "Person :name=" + name + ", age=" + age;
    }

}


public static void main(String[] args) {
        Person p1 = new Person("张三", 19);
        Person p2 = new Person("李四", 20);
        Person p3 = new Person("王五", 18);
        Collection list = new ArrayList();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        // isEmpty() 判断集合是否为空
        boolean empty = list.isEmpty();
        System.out.println(empty);
        // 返回集合容器的大小
        int size = list.size();
        System.out.println(size);
         // contains()判断集合何中是否包含指定对象
        boolean contains = list.contains(p1);
        System.out.println(contains);

// remove(); 将指定的对象从集合中删除
        list.remove(p1);

// clear() 清空集合中的所有元素
        list.clear();
        System.out.println(list);

    }

//使用集合存储自定义对象2

class Book {
    private String name;
    private double price;

public Book() {

    }

public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public double getPrice() {
        return price;
    }

public void setPrice(double price) {
        this.price = price;
    }

@Override
    public int hashCode() {
        return (int) (this.name.hashCode() + price);
    }

@Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Book)) {
            return false;
        }
        Book book = (Book) obj;
        return this.name.equals(book.name) && this.price == book.price;
    }

@Override
    public String toString() {
        return "book:@ name:" + this.name + ", price:" + this.price;
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("think in java", 100));
    col.add(new Book("core java", 200));         System.out.println(col);
    }
}

Java–集合–List：https://blog.csdn.net/lulu950817/article/details/79746895
Java–集合–Set：https://blog.csdn.net/lulu950817/article/details/79774258