集合框架是神魔嘞？！！

集合框架分为

• Collection接口
• 集合遍历
• List
• Set
• Map
• 泛型集合

collection接口

特征：存储一组不唯一，无序的对象

常用的方法为

1.  添加元素：boolean add(Object o)
2. 将集合c添加到指定集合：boolean addAll(Collection c)
3. 是否包含指定元素：boolean contains（Object o）
4. 清空：void clear（）
5. 删除元素：boolean remove（Object o）
6. 返回长度：int size（）
7. 把集合中的元素存入到数组中：Object[] toArray()

8.     public static void main(String[] args) {
        // 创建集合对象 
       	Collection<String> coll = new ArrayList<String>();                        
       	// 使用方法
       	    // 添加功能  boolean  add(String s)
       	coll.add("小谷哥");
       	coll.add("小郝弟");
       	coll.add("石破天惊");
       	System.out.println(coll);
       	    // boolean contains(E e) 判断o是否在集合中存在
       	System.out.println("判断  小郝弟 是否在集合中"+coll.contains("小郝弟"));
       	    //boolean remove(E e) 删除在集合中的o元素
       	System.out.println("删除石破天惊："+coll.remove("石破天惊"));
       	System.out.println("操作之后集合中元素:"+coll);
       	
       	    // size() 集合中有几个元素
   		System.out.println("集合中有"+coll.size()+"个元素");
   		    // Object[] toArray()转换成一个Object数组
       	Object[] objects = coll.toArray();
       	    // 遍历数组
       	for (int i = 0; i < objects.length; i++) {
           	System.out.println(objects[i]);
           }
               // void  clear() 清空集合
           coll.clear();
           System.out.println("集合中内容为："+coll);
               // boolean  isEmpty()  判断是否为空
           System.out.println(coll.isEmpty());  	
       }

集合遍历

• Iterator 

  • 特征：遍历Collection集合的统一编程接口
  • 常用方法
    1. 是否在下一个：boolean hasNext()
    2. 返回下一个元素：Object next()
    3. 移除元素：void remove()

    4. 		List list = new ArrayList<>();
       
       		//集合
       		list.add(1);
       		list.add(2);
       		list.add(3);
       
       		  //Iterator迭代器
       		    //1、获取迭代器
       		Iterator iter = list.iterator();
       		    //2、通过循环迭代
       		      //hasNext():判断是否存在下一个元素
       		while(iter.hasNext()){
       			//如果存在，则调用next实现迭代
       			    //Object-->Integer-->int
       			int j=(int)iter.next();  //把Object型强转成int型
       			System.out.println(j);
       		}

• for

  • 适用于有序集合，如ArrayList,LinkedList等

  •     List<Person> people =  ...; 
            //集合
         for (int 1=0;i<people.size();i++){
             people.get(i).setEat("java"); 
        }

• foreach

  • 适用于所有集合

  • import java.util.Arrays;
    import java.util.List;
    
    public class ForEachTester
    {
        public static void main(String[] args)
        {
            List<String> list = Arrays.asList("你好", "hello", "java");
            for( String it : list)
            {
                System.out.println(it);
            }
        }
    }
    
    ​

  List

• 特征：继承Collection接口，存储一组不唯一、有序的对象
• 实现类
  • ArrayList
    1. 底层是数组结构
    2. 查询效率高，添加删除效率低
  • LinkedList
    1. 底层是双向链表
    2. 插入、删除数据效率高，不便于快速访问数据
  • 扩充方法
    1. 根据索引获取数据：Object get(int index)
    2. 修改数据：Object set(int index,Object element)

      public static void main(String[] args) {
                  // 创建List集合对象
      	List<String> list = new ArrayList<String>();
      	
      	// 往 尾部添加 指定元素
      	list.add("图图");
      	list.add("小美");
      	list.add("不高兴");
      	
      	System.out.println(list);
      	// add(int index,String s) 往指定位置添加
      	list.add(1,"没头脑");
      	
      	System.out.println(list);
      	// String remove(int index) 删除指定位置元素  返回被删除元素
      	// 删除索引位置为2的元素 
      	System.out.println("删除索引位置为2的元素");
      	System.out.println(list.remove(2));
      	
      	System.out.println(list);
      	
      	// String set(int index,String s)
      	// 在指定位置 进行 元素修改 
      	// 修改指定位置元素
      	list.set(0, "郝三毛");
      	System.out.println(list);
      	
      	// String get(int index)  获取指定位置元素
      	
      	// 跟size() 方法一起用  来 遍历的 
      	for(int i = 0;i<list.size();i++){
      		System.out.println(list.get(i));
      	}
      	//还可以使用增强for
      	for (String string : list) {
  	        System.out.println(string);
  		}  	
  }
  

Set

• 特征：继承Collection接口，存储一组唯一、无序的对象
• Set 接口实现类中的元素是无索引的，无法通过索引来访问集合中的指定元素
• 实现类：HashSet

•  public static void main(String[] args) {
          //创建 Set集合
          HashSet<String>  set = new HashSet<String>();
          //添加元素
          set.add(new String("cba"));
          set.add("abc");
          set.add("bac"); 
          set.add("cba");  
          //遍历
          for (String name : set) {
              System.out.println(name);
          }
      }
  

Map

• 特征：存储一组成对的键-值对象，提供key到value的映射
  1. key：不要求有序，不允许重复
  2. value：不要求有序，但允许重复
• Map里的key和value是一一对应的
• 常用方法
  1. 添加数据：Object put(Object key,Object value)
  2. 根据键删除键值对元素：Object remove(Object key)
  3. 移除所有键值对元素: clear()
  4. 判断集合是否包含指定键：boolean containsKey(Object Key)
  5. 判断集合是否包含指定值：boolean containsValue(Object value)
  6. 判断集合是否为空：boolean isEmpty()
  7. 集合的长度，也就是集合中键值对的个数：is size()

     public static void main(String[] args) {
        //创建Map集合对象
            Map<String,String> map=new HashMap<>();
        //增加元素
            map.put("2001", "张三");
            map.put("2002", "李四");
            map.put("2003", "王五");
            System.out.println(map);//{2003=王五, 2002=李四, 2001=张三}
        //根据键删除元素
        //  map.remove("2001");
        //System.out.println(map);//{2003=王五, 2002=李四}
        //判断集合中是否包含指定的键返回boolean类型
            System.out.println(map.containsKey("2001"));//true
            System.out.println(map.containsKey("2004"));//false
        //判断集合中是否包含指定的值返回boolean类型
            System.out.println(map.containsValue("张三"));//true
            System.out.println(map.containsValue("赵六"));//false
        //判断集合是否为空返回boolean类型
            System.out.println(map.isEmpty());//false
        //得到集合的长度
            System.out.println(map.size());//3
        //清除所有键值对
            map.clear();
            System.out.println(map.isEmpty());
        //true，为空
    }

最后补充一下泛型集合吧

• 可以约束集合中元素的类型
• 保证类型的安全
• 常用集合ArrayList<Key,Value>，HashMap<Key,Value>等等等