Java简单基础的复习（八）Collection集合 (一)

Collection

1. 简介：
   由于数组长度是固定,当添加的元素超过了数组的长度时，则需要对数组重新定义，因为太麻烦，所以java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少 ，大大减少了工作量。
2. 数组和集合的区别
   1. 区别1：
      • 数组既可以存储基本数据类型（存储的是值），又可以存储引用数据类型（存储的是引用数据的地址）
      • 集合只能存储引用数据类型（就是对象），存储基本数类型时会自动封装
   2. 区别2：
      • 数组的长度是固定的
      • 集合的长度会随着数据的增加而增加
3. 集合和数组应用时机：
   • 如果数据长度固定，建议使用数组，比较简单方便，如果数据长度不确定，则使用集合对象，能够大大加强工作效率。
4. 集合的继承体系
   

Collection的方法

1. boolean add(Object o)

//add方法使用示范  若果是List集合一直都返回true因为List集合中是可以存储重复元素的
//如果是set集合当存储重复元素的时候，就会返回false
//ArrayList的父类的父类的重写toString方法，所以在打印对象的引用的时候，输出的结果不是object类中的tostring的结果
		Collection<Object> c = new ArrayList<Object>();
		boolean b1 = c.add("abc");
		boolean b2 = c.add(true);//自动装箱new Boolean（true）
		boolean b3 = c.add(100);
		boolean b4 = c.add("abc");//ArrayList中可以重复
		boolean b5 = c.add(new Student("张三",23));
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
		System.out.println(b4);
		System.out.println(b5);
		System.out.println(c.toString());

2. boolean remove(Object o)

		Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("b");
		 c.add("c");
		 c.remove("b");//删除指定元素
		System.out.println(c.toString());

3. void clear()

		Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("b");
		 c.add("c");
		System.out.println(c.toString());
		c.clear();//清空集合
		System.out.println(c.toString());

4. boolean contains(Object o)

		Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("b");
		 c.add("c");
		System.out.println(c.toString());
		System.out.println(c.contains("b"));//判断是否包含指定元素

5. boolean isEmpty()

		Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("b");
		 c.add("c");
		System.out.println(c.toString());
		System.out.println(c.isEmpty());//判断是否为空

6. int size()

		Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("b");
		 c.add("c");
		System.out.println(c.toString());
		System.out.println(c.size());//获取元素的个数

7. toArray()

		//集合遍历之集合转数组遍历
		Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("b");
		 c.add("c");
		 c.add("d");
		 Object[] arr = c.toArray();//将集合转换成数组
		 for(int i =0;i<arr.length;i++) {
			 System.out.println(arr[i]);
		 }

8. boolean addAll(Collection c)
   (将指定Collection中的所有元素添加到此Collection中)

		 Collection c1 = new ArrayList();
		 c1.add("a");
		 c1.add("b");
		 c1.add("z");
		 c1.add("c");
		 c1.add("d");
		 Collection<Object> c = new ArrayList<Object>();
		 c.addAll(c1);//将c1添加到c中
		 System.out.println(c);

9. boolean removeAll(Collection c)

		 Collection c1 = new ArrayList();
		 c1.add("a");
		 c1.add("b");
		 c1.add("z");
		 c1.add("c");
		 c1.add("d");
		 Collection<Object> c = new ArrayList<Object>();
		 c.add("e");
		 c.addAll(c1);//将c1添加到c中
		 System.out.println(c.toString());
		boolean b = c.removeAll(c1);//删除的是交集
		System.out.println(b);
		System.out.println(c.toString());

11. boolean containsAll(Collection c)

		 Collection c1 = new ArrayList();
		 c1.add("a");
		 c1.add("b");
		 c1.add("z");
		 c1.add("c");
		 c1.add("d");
		 Collection<Object> c = new ArrayList<Object>();
		 c.addAll(c1);
		 boolean b = c.containsAll(c1);//判断调用的集合是否包含传入的集合
		 System.out.println(b);

12. boolean retainAll(Collection c)

		 Collection c1 = new ArrayList();
		 c1.add("a");
		 c1.add("b");
		 c1.add("z");
		 c1.add("c");
		 c1.add("d");
		 Collection<Object> c = new ArrayList<Object>();
		 c.add("a");
		 c.add("e");
		  //取交集，如果调用的集合改变就返回true，如果调用的集合不变就返回false
		 boolean b = c.retainAll(c1);//取交集
		 System.out.println(b);

Collection的迭代遍历

1. 迭代器Iterator：对Collection进行迭代的迭代器。
2. 方法：
   • hasNext()：如果仍有元素可以迭代，则返回true
   • next()：返回迭代的下一个元素
   • remove()：从迭代器指向的Collection中移除迭代器返回的最后一个元素
3. 代码演示：

		 //迭代器
		 Collection c = new ArrayList();
		 c.add(new Student1("zjf",23));
		 c.add(new Student1("gzq",24));
		 c.add(new Student1("xxp",25));
		 c.add(new Student1("wrq",26));
		 //对集合中的元素迭代（遍历）
		 Iterator it = c.iterator();
		 while(it.hasNext()) {
			 Student s = (Student)it.next();//向下转型
			 System.out.println(s.getName());
		 }

List集合

1. 简介：
   有序集合（也称为序列 ）。 该界面的用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。
2. 方法：
   void add(int index, E element) ：将指定的元素插入此列表中的指定位置。

		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list.toString());
		list.add(1,"e");
		System.out.println(list.toString());

int indexOf(Object o) ：返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list.indexOf("a"));

E remove(int index) ：删除该列表中指定位置的元素。

		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list.toString());
		list.remove(1);//删除的时候不会自动装箱，把1当作索引
		System.out.println(list.toString());

E get(int index) ：返回此列表中指定位置的元素。

		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list.get(1));

E set(int index, E element) ：用指定的元素（可选操作）替换此列表中指定位置的元素。

		List list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		System.out.println(list.toString());
		list.set(1,"a");
		System.out.println(list.toString());

Vector

1. 简介：
   Vector类实现了可扩展的对象数组。 像数组一样，它包含可以使用整数索引访问的组件。 但是， Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。
2. 方法：
   • public void addElement(E obj)：将指定的组件添加到此向量的末尾，将其大小增加1。
   • public E elementAt(int index)：返回指定索引处的组件。
   • public Enumeration elements() ：返回此向量的组件的枚举。

List三个子类的特点

• ArrayList:
  底层数据结构是数组，查询快，增删慢。
  线程不安全，效率高。
• LinkedList:
  底层数据结构是链表，查询慢，增删快。
  线程不安全，效率高。
• Vector:
  底层数据结构是数组，查询快，增删慢。
  线程安全，效率低。
  Vector相对ArrayList查询慢(线程安全的)
  Vector相对LinkedList增删慢(数组结构)
• Vector和ArrayList的区别
  Vector是线程安全的,效率低
  ArrayList是线程不安全的,效率高
  共同点:都是数组实现的
• ArrayList和LinkedList的区别
  ArrayList底层是数组结果,查询和修改快
  LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
  共同点:都是线程不安全的