day12_collection

1 集合框架

1.1 概念

容器：装多个数据的对象
数组：装指定个数个 相同类型数据的容器
集合：装任意个数个 任意引用类型数据的容器
概念中分析集合的特点：1 元素个数可变
                  2 元素类型必须是引用数据类型
                  3 元素类型可以不同

• 集合和数组的区别

概念：数组 装指定个数个 相同类型数据的容器
     集合：装任意个数个 任意引用类型数据的容器
相同之处：都是容器 都是引用数据类型
不同之处：1 元素个数是否固定
                  数组一单创建 元素个数不能更改
                  集合 元素个数可以更改
        2  元素之间类型是否相同
                   数组创建时必须指定元素类型 只能装对应类型的元素
                   集合中元素的类型可以不同
        3  可装的元素类型不同
                    数组可以装任意数据类型的元素
                    集合只能装引用数据类型的元素
        4   元素是否有默认值
                    数组创建时 元素不赋值 有默认初始值
                    集合元素没有默认初始值

1.2 集合框架结构

顶层接口1： Collection   单列集合的顶层接口：每次增删改查操作的是一个数据
          ---子接口11: List  有序列表(元素有下标)
              --实现类111:ArrayList 底层长度可变的数组的实现 线程不安全
              --实现类112:LinkedList 链表
              --实现类113:Vector    底层长度可变的数组的实现 线程安全
          ---子接口12：Set   无序 不重复列表(元素没有下标)
              --实现类121:HashSet : 无序不重复
              --实现类122:TreeSet : 元素排序 不重复
顶层接口2： Map          双列集合的顶层接口：每次增删改查操作的是一对数据 
          ---实现类21: HashMap  :基于Hash表的Map的实现：：可以有null值和null键 键不能重复
          ---实现类22: TreeMap  : 基于红黑树的Map的实现：：Key按自然顺序排序
          ---实现类23: HashTable  : 与HashMap相同 但不允许null值和null键 并且是线程安全的

1.3 集合框架的学习重点

1 集合框架的结构
2 每种实现类的特点
3 功能相似的实现类之间的不同之处
4 每种常用集合实现类的遍历方式

2 Collection

单列集合的顶层接口：其方法和遍历方式 对所有的单列集合通用

2.1 Collection的方法

注意：在api中 <>就当没有  E 就当Object即可

/*
	 * Collection的方法
	 * 1 boolean add(E e)  添加一个：返回值 是添加成功或者失败(set不允许重复) 
	 *   boolean addAll(Collection co) 把参数集合中的元素都添加到当前集合中 
	 * 2 boolean remove(Object o)  ：删除一个
	 *   boolean removeAll(Collection<?> c)  :删除多个
	 *   void clear()                        ： 清空集合
	 * 3 int size()                          ： 获取元素个数
	 * 4 boolean contains(Object o)          ：判断是否包含参数元素
	 *   boolean containsAll(Collection<?> c)  ：判断是否包含参数集合中的所有元素 
	 *   boolean isEmpty()                    ： 判断当前集合的元素个数是否为0
	 * 5 Object[] toArray()                  ：获取对应的数组
	 * 6 boolean retainAll(Collection<?> c)  ：只保留当前集合和参数集合的交集
	 * 7 Iterator<E> iterator()              : 获取当前集合的迭代器对象(类似于仓库的一次性入库清单)            
	 * 
	 * */
Collection c1=new ArrayList();
System.out.println("添加：：："+c1.add("abc"));
System.out.println("添加：：："+c1.add("abc"));
Collection c2=new ArrayList();
c2.add("123"); c2.add("123ac"); c2.add("123ab");
//c1.add(c2);//把c2作为一个元素添加到c1中
c1.addAll(c2);//把c2中所有的元素添加到c1中
System.out.println("元素个数："+c1.size());

//System.out.println("删除一个："+c1.remove("abc"));
//System.out.println("删除多个："+c1.removeAll(c2));
//c1.clear();//清空所有元素
System.out.println("添加：：："+c1.add(111));//自动装箱
System.out.println("元素个数："+c1.size());

Object[] arr=c1.toArray();//获取集合对应的数组
//传统for循环
for (int i = 0; i < arr.length; i++) {
    System.out.println("arr["+i+"]="+arr[i]);
}

• 简洁for循环

//简洁for循环：唯一优点：代码少 简洁
//             缺点：无法获取元素下标
//                   循环过程中不能对元素进行增删：：ConcurrentModificationException
//简洁for循环：foreach  遍历容器：集合+数组
for(Object obj:arr) {//循环拿引用obj按顺序接收容器arr中的元素
    System.out.println("obj="+obj);
}
//使用简洁for循环集合
for(Object obj:c1) {//循环拿引用obj按顺序接收容器arr中的元素
    System.out.println("obj==="+obj);
    if(obj.equals("abc")) {
        //c1.add("abc新的");//ConcurrentModificationException
        //c1.remove(obj);//ConcurrentModificationException
    }
}
System.out.println("让c1只保留与c2的交集：："+c1.retainAll(c2));
System.out.println("元素个数："+c1.size());

• 迭代器

		 //迭代器遍历
		 Iterator it=c1.iterator();//获取迭代器对象
//		 while(true) {
//			 System.out.println("it.hasNext()判断是否还有元素可以遍历：：=="+it.hasNext());
//			 System.out.println("it.next()获取一个元素=="+it.next());//NoSuchElementException
//		 }
		 while(it.hasNext()) {//循环判断是否还有元素可以遍历
			 System.out.println("it.next()获取一个元素=="+it.next());
		 }
		 it=c1.iterator();//再次获取迭代器对象
		 while(it.hasNext()) {//循环判断是否还有元素可以遍历
			 System.out.println("it.next()获取一个元素====="+it.next());
		 } 

2.2 Collection的遍历方式

public static void showCollection(Collection c) {
    //1 简洁for循环
    for(Object obj:c) {//循环拿引用obj按顺序接收容器arr中的元素
        System.out.println("方式1：：：obj="+obj);
    }
    //2 迭代器：
    Iterator it=c.iterator();//获取迭代器对象
    while(it.hasNext()) {//循环判断是否还有元素可以遍历
        System.out.println("方式2：：：：获取一个元素=="+it.next());//获取一个元素
    }
    //3 获取对应的数组 遍历数组
    Object[] arr=c.toArray();//获取集合对应的数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println("方式3：：：arr["+i+"]="+arr[i]);
    }
}

3 ArrayList

ArrayList是Collection的子接口的List的实现类：：
ArrayList拥有Collection中所有的方法和遍历方式

3.1 方法

     * ArrayList:
     * 可以包含null元素的 大小可变数组的实现
     *构造方法：
     *  1： ArrayList()  初始容量是10 ：：：容量可以自动增长:每次增加0.5
     *  2：ArrayList(Collection<? extends E> c) ：：把参数集合中的元素作为初始元素创建一个集合
     *普通方法：
     *   1   void add(int index, E e)   ；把e添加到index位置处
     *       boolean addAll(int index, Collection c) ：把 c中的所有元素添加到index位置处
     *   2   E get(int index)           ；获取index位置处的元素
     *       set(int index, E e)  ：设置index位置处的元素为e
     *   3   int indexOf(Object o)   : 获取参数元素第一次出现的位置：如果找不到返回-1
     *       int lastIndexOf(Object o) : 倒着找获取参数元素第一次出现的位置：如果找不到返回-1
     *   4   E remove(int index)     ：删除index位置处的元素

3.2 遍历

public static void showList(ArrayList list) {
    //1 简洁for循环
    for(Object obj:list) {//循环拿引用obj按顺序接收容器arr中的元素
        System.out.println("方式1：：：obj="+obj);
    }
    //2 迭代器：
    Iterator it=list.iterator();//获取迭代器对象
    while(it.hasNext()) {//循环判断是否还有元素可以遍历
        System.out.println("方式2：：：：获取一个元素=="+it.next());//获取一个元素
    }
    //3 获取对应的数组 遍历数组
    Object[] arr=list.toArray();//获取集合对应的数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println("方式3：：：arr["+i+"]="+arr[i]);
    }
    //4 根据下标获取元素
    for (int i = 0; i < list.size(); i++) {
        System.out.println("方式4：：：list.get("+i+")="+list.get(i));
    }
}

4 HashSet

4.1 方法

	 *HashSet:
	 *  底层由哈希表支持的set的实现类：无序 不重复  元素可以为null
	 *与Collection比较 无特有方法：
	 *    boolean add(E e)  

//		  HashSet set1=new HashSet(); 
//		  System.out.println("第一次添加："+set1.add("abc"));//true
//		  System.out.println("第二次添加："+set1.add("abc"));//false
//		  System.out.println("第三次添加："+set1.add("abc"));//false

4.2 HashSet保证不重复的原理

package day12_collection;

import java.util.HashSet;

public class Demo03HashSet {
	/*
	 *研究HashSet怎么保证元素的不重复：：：set.add(obj)
	 *  1 调用参数对象obj的hashCode方法获取其hashCode值  如果此值在set中唯一 直接添加
	 *  2 如果obj的hashCode值和set中n个元素的hashCode值相等
	 *     调用obj的equals方法 分别与这n个元素做比较
	 *  3 只有当这n次比较都返回false 才允许添加
	 * */
	public static void main(String[] args) {
		
		
		 HashSet set=new HashSet();
		 for (int i = 1; i <=10; i++) {
			  System.out.println("添加第"+i+"个元素：："+set.add(new Demo03(i)));
		 } 
		 
		  for (Object obj : set) {
		      System.out.println("obj="+obj);
	      }
		  
		  
	}
}
class Demo03{
	int age;
	public Demo03(int age) {this.age = age;}
	
	private static int n=0;
	{//构造代码块：
		n++;num=n;
	}
	final int num;//记录当前对象创建的顺序
	@Override
	public String toString() {
		return "Demo03 [num=" + num + ",age="+age+" ]";
	}
	@Override
	public int hashCode() {
		int hashCode=age%3;
		System.out.println(this+"：：的hashCode方法被调用  当前对象的hashcode值是::::"+hashCode);
		return hashCode;
	}
	@Override
	public boolean equals(Object obj) {
		
		System.out.println(this+"：：的equals方法被调用  比较的对象是::::"+obj);
		//return super.equals(obj);
		if(!(obj instanceof Demo03)) { return false;}
		Demo03 d=(Demo03)obj;
		return this.age%2==d.age%2;
	}
}

5 练习

	 *1 创建一个list装20个元素 有整数和字符串
	 *2 获取其中 整数的平均值
	 *3 删除所有的整数元素
	 *4 对其中的剩余的字符串元素进行排序： 先比较长度  长度相同再逐个字符做比较
	 * 
	 * abc1  abc12  abc123 abc1111 abc2
	 * abc1111  abc123  abc12 abc2 abc1
	 *
	 *5 创建一个set装10个student：sname sex score
	 * 要求sname相同 sex相同 score相差10分被视为两个对象相等  不允许重复添加