集合概述

由来

• 存放单个数据内容，声明一个变量。

内存中声明一个小格子，然后放进去

• 存放多个类型相同的数据内容，声明一个一维数组。

内存中申请一段连续的存储单元，里面分成多个小格子。一维数组缺陷：里面的数据类型必须都一样

• 存放多个类型不同的数据内容，则创建一个对象。

对象里面可以声明不同类型的成员变量进行存放

• 存放多个类型相同的对象数据，创建一个对象数组。

数组中每个元素就是一个类的对象

以上无论是存放单个还是多个对象，有一个特点，对应存储的类型都必须都一致。

当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。

框架结构

Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。

其中Collection集合中存取元素的基本单位是：单个元素。

Collection集合里面存放元素都是一个个放入

其中Map集合中存取元素的基本单位是：单对元素。

map集合里面是一对对的放

Collection集合

概念

java.util.Collection接口是List、Queue及Set接口的父类接口，所以Collection里定义的方法既可用于操作List集合，也可用于操作Queue集合和Set集合。

常用方法

集合添加

add

多态声明集合

//1.准备一个Collection集合
//Collection c = new Collection();//接口不能实例化，不能创建对象
//接口类型的引用指向实现类对象，形成多态
Collection c1 = new ArrayList();
System.out.println("集合中的元素有："+ c1);//[]

集合添加String

//2.集合中添加元素
boolean addFlag = c1.add(new String("first"));
System.out.println("集合添加结果："+addFlag);
System.out.println("集合中的元素有："+ c1);//[first]

集合添加包装类Integer

addFlag = c1.add(Integer.valueOf(66));
System.out.println("集合添加结果："+addFlag);
System.out.println("集合中的元素有："+ c1);//[first,66]

集合添加对象

addFlag = c1.add(new Person("小七",26));
System.out.println("集合添加结果："+addFlag);
System.out.println("集合中的元素有："+ c1);//[first, 66, Person{name='小七', age=26}]

• 打印集合中所有的元素，本质上打印集合的每个对象，也就是每个对象调用对应类的toString方法

addAll

重新声明一个集合

Collection c2 = new ArrayList();
c2.add(45);//自动装箱
c2.add("nnnn");//常量池，2种创建String，一个new String「创建的内容在常量池，一个在堆区」，一个直接字符串「对应内容在常量池」
System.out.println("c2:"+c2);//[45, nnnn]

集合元素一个个添加

//3.集合添加多个元素打印
//c2所有元素全部添加到c1中   也就是将集合c2中元素一个个依次添加到集合c1中
boolean b = c1.addAll(c2);
System.out.println(c1);

集合当成对象添加

//表示将集合c2整体看做一个元素添加到c1集合中
boolean add = c1.add(c2);
System.out.println(c1);//[first, 66, Person{name='小七', age=26}, 45, nnnn, [45, nnnn]]

总结

• 集合中添加单个元素或单个对象，使用add()
• 集合中添加多个元素，使用addAll()

集合判断

contains

Object是该方法的形参，说明对应里面可以传入任何的实体类参数

判断String

boolean b1 = c1.contains(new String("first"));
System.out.println("b1:"+b1);//true
b1 = c1.contains("second");
System.out.println("b1:"+b1);//false

判断Integer

b1 = c1.contains(66);
System.out.println("b1:"+b1);//true
b1 = c1.contains(77);
System.out.println("b1:"+b1);//false

判断对象

Object是万物皆对象，Objects是一个工具类

• contains工作原理
  • 拿着参数对象与集合中已有元素依次进行比较，比较的方式就是调用Objects的equals方法
• Objects.equals(o, e)
  • o代表contains的形参 e代表集合的每个元素

 public static boolean equals(Object a, Object b) {
     return (a == b) || (a != null && a.equals(b));
 }

• a代表Person对象
• b代表集合中已有对象
• || 逻辑或 ： 一真为真，同假为假
• 元素包含方式
  • 第一种：Person对象与集合中已有对象的地址相同
  • 第二种：Person对象不为空，则Person对象调用equals方法与集合中已有元素相等

Person中没有重写equals方法，则调用的是Object类中继承下来的equals方法，比较2个对象的地址 false

代码示例：

//Objects.equals(o, e)
/**    a代表Person对象 b代表集合中已有对象
*     public static boolean equals(Object a, Object b) {
*         return (a == b) || (a != null && a.equals(b));
*         元素包含的第一种方式：Person对象与集合中已有对象的地址相同
*                  第二种方式：Person对象不为空，则Person对象调用equals方法与集合中已有元素相等
*     }
*     || 逻辑或  一真为真，同假为假
*/
//o代表contains的形参 e代表集合的每个元素
//contains工作原理  拿着参数对象与集合中已有元素依次进行比较，比较的方式就是调用Objects的equals方法
//Person中没有重写equals方法，则调用的是Object类中继承下来的equals方法，比较2个对象的地址  false
//Person中重写，对应的就是true
b1 = c1.contains(new Person("小七",26));
System.out.println("b1:"+b1);//true  false

总结

• Integer 、String 对应的java里面就给重写equals方法；
• 只有我们自定义的类没有重写

containsAll

创建集合c3

//[first, 66, Person{name='小七', age=26}, 45, nnnn, [45, nnnn]]
Collection c3 = new ArrayList();
c3.add(66);
System.out.println("c1:"+c1);//[first, 66, Person{name='小七', age=26}, 45, nnnn, [45, nnnn]]
System.out.println("c3:"+c3);//[66]

c1是否包含c3所有元素

//判断c1是否包含c3中所有元素
b = c1.containsAll(c3);
System.out.println("b:"+b);//true

• c3再次添加个元素不在c1内，对应的再次判断

c3.add("one");
System.out.println("c1:"+c1);//[first, 66, Person{name='小七', age=26}, 45, nnnn, [45, nnnn]]
System.out.println("c3:"+c3);//[66, one]
//判断c1是否包含c3中所有元素
b = c1.containsAll(c3);
System.out.println("b:"+b);//false

contains-containsAll区别

Collection c4 = new ArrayList();
c4.add("first");
c4.add(66);
System.out.println("c4:"+c4);//[first, 66]

b = c1.containsAll(c4);
//判断c1里面是否有集合c4的所有元素
System.out.println("c1-containsAll-c4:"+b);//true
b = c1.contains(c4);
//判断c1里面是否有集合c4这个整体为单元的元素
System.out.println("c1-contains-c4:"+b);//false

• 如果想要判断结果反过来怎么弄呢？？

Collection c5 = new ArrayList();
c5.add(88);
c5.add("nnnn");

boolean add1 = c1.add(c5);
System.out.println("c1:"+c1);//[first, 66, Person{name='小七', age=26}, 45, nnnn, [45, nnnn]]
b = c1.containsAll(c5);
//判断c1里面是否有集合c5的所有元素
System.out.println("c1-containsAll-c5:"+b);//false
b = c1.contains(c5);
//判断c1里面是否有集合c5这个整体为单元的元素
System.out.println("c1-contains-c5:"+b);//true

• contains：判断的是集合里面的所有元素
• containsAll：判断的是集合作为对象整体

集合删除

• 单个元素删除，所有元素删除

remove

删除集合没有的元素

//[first, 66, Person{name='小七', age=26}, 45, nnnn, [45, nnnn], [88, nnnn]]  
System.out.println("c1:"+c1);  
System.out.println("----开始删除----");  
//删除集合没有的元素  
b = c1.remove(1);  
System.out.println("c1:"+c1);  
System.out.println("c1-remove-不存在元素:"+b);//false  
System.out.println("----开始删除----");

删除集合存在的元素

//删除集合存在的元素  
b = c1.remove(66);  
System.out.println("c1:"+c1);  
System.out.println("c1-remove-存在元素:"+b);//true  
System.out.println("----开始删除----");

删除集合对象

//删除集合对象  
b = c1.remove(new Person("小七",26));  
System.out.println("c1:"+c1);  
System.out.println("c1-remove-对象:"+b);//true

• remove方法的工作原理：Objects.equals(o, e)

removeAll

删除集合没有的元素

System.out.println("c3:"+c3);//[66, one]  
System.out.println("c1:"+c1);//[first, 45, nnnn, [45, nnnn], [88, nnnn]]  
System.out.println("----开始删除----");  
b = c1.removeAll(c3);  
System.out.println("c1:"+c1);//[first, 45, nnnn, [45, nnnn], [88, nnnn]]  
System.out.println("c1-removeAll-不存在:"+b);//false

删除集合存在的元素

System.out.println("c4:"+c4);//[first, 66]  
System.out.println("c1:"+c1);//[first, 45, nnnn, [45, nnnn], [88, nnnn]]  
System.out.println("----开始删除----");  
b = c1.removeAll(c4);  
System.out.println("c1:"+c1);//[45, nnnn, [45, nnnn], [88, nnnn]]  
System.out.println("c1-removeAll-存在:"+b);//true  
//有几个删几个  
//本质上就是一个个元素进行删除，有元素删除，否则就不删除，只要删除一个就算true

• 本质上就是一个个元素进行删除，有元素删除，否则就不删除，只要删除一个就算true

删除整体集合对象c3

b1 = c1.remove(c3);

集合其它方法

//[45, nnnn, [45, nnnn], [88, nnnn]]  
System.out.println("集合中元素的个数："+ c1.size());  //4
System.out.println(0==c1.size() ? "集合空了":"集合没空");//集合没空  
System.out.println(c1.isEmpty() ? "集合空了":"集合没空");//集合没空  
//清空集合的所有元素  
c1.clear();  //[]
System.out.println("集合中元素的个数："+ c1.size());  //0
System.out.println(0==c1.size() ? "集合空了":"集合没空");//集合空了  
System.out.println(c1.isEmpty() ? "集合空了":"集合没空");//集合空了

集合判断是否相等

Collection co1 = new ArrayList();  
co1.add(1);  
co1.add("test");  
Collection co2 = new ArrayList();  
co2.add(1);  
co2.add("test");  
System.out.println("co1:"+co1);//[1, test]  
System.out.println("co2:"+co2);//[1, test]  
boolean b2 = co1.equals(co2);  
System.out.println(b2);//true

集合转换为数组

//集合转数组   通常认为：集合是用于取代数组的结构  
//实现集合向数组类型的转换  
Object[] objects = co1.toArray();  
// 打印数组中的所有元素  
System.out.println("数组中的元素有：" + Arrays.toString(objects)); //[1, test]

数组转换为集合

// 实现数组类型到集合类型的转换  
Collection objects1 = Arrays.asList(objects);  
System.out.println("集合中的元素有：" + objects1);//[1, test]

迭代

java学习是一个迭代的过程，我今天用到的知识不只是今天的知识还有可能是昨天的，前天的，大前天的。所以我们学习一个体系的知识不是只学会当前的就可以了。

[[02.迭代器]]