【Java基础】集合(1) —— Collection

【Java基础】集合(1) —— Collection
【Java基础】集合(2) —— List
【Java基础】集合(3) —— Set
【Java基础】集合(4) —— 泛型
【Java基础】集合(5) —— Map
【Java基础】集合(6) —— Collections

• 存储不同类型的对象:
  • Object[] arr=new object[5];
  • 数组的长度是固定的, 添加或删除数据比较耗时
• 集合:
  • Object[] toArray
  • 可以存储不同类型的对象
  • 随着存储的对象的增加，会自动的扩容
  • 集合提供了非常丰富的方法，便于操纵
  • 集合相当于容器，可以存储多个对象
  • 集合存的是对象的引用

每种集合存储数据的方式不同，使用的数据结构不同，有各自的优缺点

在项目中根据底层的数据结构选择适合的集合使用。

共性方法

Collection中定义的是最共性的方法:

1. 添加

   • boolean add(Object o)
     多态集合中存储的都是对象集合中存储的是对象的地址
   • boolean addAll(Collection<? extends E> c)
     把另一个集合中的数据加入到当前集合

   Collection col=new ArrayList();
   col.add("java");
   col.add("html");
   col.add("mysql");
   col.add(66);
   Collection col2=new ArrayList();
   col2.add("bigdata");
   col2.add("python");
   col.addAll(col2);
   sop(col);//[java, html, mysql, 66, bigdata, python]
   

2. 删除

   • boolean remove(Object o)
     从集合中删除某个对象
   • boolean removeAll(Collection<?> c)
     从当前集合中删除和另一个集合相同的数据
   • boolean retainAll(Collection c)
     从当前集合中保留和另一个集合相同的数据
   • void clear()
     清空集合
   • boolean removelf(Predicate predicate) boolean test(T t)
     依次遍历集合中的每个对象，如果test方法返回true，则删除这个对象

   //使用匿名内部类实现test方法：
   col.removeIf(new Predicate(){
   	public boolean test(Object t){//参数用来依次接收集合中每个对象
   		 if(t instanceof String){
   			  String ss=(String)t;
   			  if(ss.startsWith("java"))
   				  return true;
   		 }
   		 return false;
   	}
   });
   

   //使用lambda表达式实现test方法:
   col.removeIf(t->{
   		if(t instanceof String){
   			  String ss=(String)t;
   			  if(ss.startsWith("java"))
   				  return true;
   		 }
   		 return false;
   }); 
   //简化书写:
   col.removeIf(t->((String)t).startsWith("java"));
   

3. 判断

   • boolean contains(Object o)
     判断是否包含某个对象
     依据equals方法判断是否包含某个元素

   import java.util.*;
   class Demo2{
   	public static void main(String[] args){
   		ArrayList list=new ArrayList();
   		list.add(new Student("zhangsan",20));
   		list.add(new Student("lisi",25));
   		list.add(new Student("lisi",25));
   		//姓名年龄相同的认为是同一个对象，去重
           ArrayList list2 = quChong(list);
   		System.out.println(list2);
   	}
   	//去除集合中重复的元素
   	public static ArrayList quChong(ArrayList list){
   		ArrayList list2=new ArrayList();
           for(int i=0;i<list.size();i++){
   			 Object obj = list.get(i);//判断新集合中是否包含该元素
   			 if(!list2.contains(obj))//依据equals方法判断是否包含
   				 list2.add(obj);
   		}
           return list2;
   	}
   }
   class Student{
   	………………
   	public boolean equals(Object obj){
   		if(!(obj instanceof Student))
   			throw new ClassCastException("类型不对");
   		Student stu=(Student)obj;
           return this.name.equals(stu.name)&&this.age==stu.age;
   	}
   }
   

   • boolean containsAll(Collection<?> c)
     判断是否包含另一个集合中的所有对象
   • boolean isEmpty()
     判断集合是否为空
   • boolean equals(Object o)
     判断两个集合中的对象是否都一致

4. 获取

   • Iterator iterator()
     获取集合中的对象
     在使用迭代器迭代的过程中不允许对集合进行添加，修改，删除元素

   Iterator ite = col.iterator();//得到集合的迭代器
   while(ite.hasNext()){
   	Object obj = ite.next();
       //col.add("haah"); 
       //ConcurrentModificationException 
       //在使用迭代器迭代的过程中不允许对集合进行添加，修改，删除元素
   	System.out.println(obj);
   }
   while(ite.hasPrevious()){
   	Object obj=ite.previous();
   	System.out.println(obj);
   }
   

   • default void forEach(Consumer<? super T> action) void accept(T t) 参数用来依次接收集合中的每个对象

   col.forEach(t->System.out.println(t));
   col.forEach(System.out::println);
   

   • int size()
     获取集合中对象的个数

5. 集合变数组

   • Object[] toArray()
     防止被随意地添加或删除

6. 遍历集合的三种方式

   • Iterator iterator()
   • forEach()
   • 增强的for循环可以用于数组和Collection集合

   for(Object obj:col)
   {
   	System.out.println(obj);
   }