集合框架

集合框架包含的内容：

集合框架是为了表示和操作集合而规定的一种统一的标准体系结构，集合的框架都包括三大内容：对外的接口，接口的实现和对集合运算的算法；

接口：表示集合的抽象数据类型

实现：集合框架中接口的具体实现

算法：在一个实现了某个集合框架的接口的对象身上完成某种有用的计算方法

Java中的两大类接口：collection （包含两个子接口List和set）和map。通常说的Java集合框架共有三大类接口：List ，Set和 Map，他们的共同点是：都是集合接口都可以用来存储很多对象，它们的区别如下：

Collection：接口存储的一组不唯一（允许重复） ，无序的对象

Set接口继承Collection接口：存储一组不唯一的（不允许重复），无序的对象

List接口继承Collection接口:存出一组不唯一的（允许重复） 有序（以元素插入的次序来放置元素，不会重新排列）的对象

Map接口:存储的一组成对的键-值对象，提供key到value 的映射，Map中的key不要求有序，不允许重复，value同样不要求有序，但是允许重复

Iterator接口:是负责定义访问和遍历元素的接口

List接口

ArryList 和LinkedList

ArrayList对数组进行了封装，实现了长度可变的数组，ArrayList存储的数据的方式和数组相同，都是在内存中分配连续的空间，它的优点是在于遍历元素和随机访问元素的效率比较高

LinkedList采用链表存储方式，优点在于插入，删除元素时效率比较高，他提供了额外的addFirst（），addLast（），removeFirst（）和removeLast（）等方法，可以再LinkedList的首部或者是尾部进行插入和删除操作，这些方法使得Linkedlist可被用作堆栈（stack）和队列（queue）

ArrayList集合类：

1：创建多个对象

2：创建ArrayList集合对象，并把对象放入其中

3：输出集合中的数量

4：通过遍历集合显示信息

package JavaOPPDay01;
import java.util.ArrayList;
public class Day01 {

    public static void main(String[] args) {
        ArrayList<Person> heros =new ArrayList<Person>();

        Person p1 =new Person();
        p1.setName("小胖");
        p1.setMoney("100000");
      
        Person p2 =new Person();
        p2.setName("小丽");
        p2.setMoney("200000");
        
        Person p3 =new Person();
              p3.setName("小妹");
              p3.setMoney("200000");
        heros.add(p1);
        heros.add(1, p3);
        heros.add(p3);
        //for遍历
        //for(int i=0;i<heros.size();i++){
            //System.out.println(heros.get(i).getName());
        //}
        //删除一个人
        heros.remove(0);
        heros.remove(p2);
        //for增强
        for(Person person:heros){
            System.out.println(person.getName());
        }
        //查看是否有这个人
         if (heros.contains(p2)){
          System.out.println("has");
    }else{
        System.out.println("hasnot");
    }
}
    }

package JavaOPPDay01;

public class Person {

    private String name;
    private String Money;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getMoney() {
        return Money;
    }
    public void setMoney(String money) {
        Money = money;
    }
}

//删除一个人
        heros.remove(0);
        heros.remove(p2);

 //查看是否有这个人
         if (heros.contains(p2)){
          System.out.println("has");
    }else{
        System.out.println("hasnot");
    }

LinkedList集合类

一些特殊的方法：

package JavaOPPDay02;
import java.util.LinkedList;


import JavaOPPDay01.Person;
public class Day01 {

    public static void main(String[] args) {
        LinkedList<Person> heros =new LinkedList<Person>();
        Person p1 =new Person();
        p1.setName("小胖");
        p1.setMoney("100000");
        
        Person p2 =new Person();
        p2.setName("小美");
        p2.setMoney("100000");
        
        Person p3 =new Person();
        p3.setName("小红");
        p3.setMoney("100000");
        
        heros.add(p1);
        heros.add(p2);
        heros.addFirst(p3);
        
        //for遍历
        for(Person person:heros){
            System.out.println(person.getName());
        }
        //删除
       heros.removeLast();
       System.out.println(" ------------------------------------ ");
       for(Person person:heros){
           System.out.println(person.getName());
       }
       System.out.println("------------------------------------");
       //LinkedList有get吗
       Person pp =heros.get(1);
       System.out.println(pp.getName());
    }

}

package JavaOPPDay02;

public class Person {

    private String name;
    private String Money;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getMoney() {
        return Money;
    }
    public void setMoney(String money) {
        Money = money;
    }
}

 heros.removeLast();

       Person pp =heros.get(1);
       System.out.println(pp.getName());

Map接口：

HashMap集合类：

package JavaOPPDay04fanxing;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test {
//导包Ctrl+shift+o
    public static void main(String[] args) {
        Map<String,String>  map =new HashMap<String,String>();
        map.put("CBC","中国建设银行");
        map.put("ABC","中国农业银行");
        map.put("ICBC","中国工商银行");
        //双列的集合遍历方式，不能使用For下标 ，是因为他没有下表
        //方式一：for：通过keys集合遍历value
        Set<String> set =map.keySet();
        for(String key:set){
            System.out.println(key);
            //key有了，Value如何获取
            //System.out.println(map.get(key));(可选择运行)
        }

//方式二：直接遍历value
        Collection <String> collection =map.values();
        for(String value:collection){
            System.out.println(value);
        }

Set<Entry<String, String>> entrySet = map.entrySet();
        for(Entry<String,String>entry:entrySet){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

//方案四：迭代器遍历
        System.out.println("============");
        Set<String> keySet = map.keySet();
        Iterator <String> iterator =keySet.iterator();
         while(iterator.hasNext()){
        String key =iterator.next();
        System.out.println(key);
        System.out.println(map.get(key));
    }

 //方案五：迭代器遍历 key+value同时遍历
         Iterator<Entry<String, String>> iterator2 = map.entrySet().iterator();
         //见到Iterator 就要使用while循环
        while(iterator2.hasNext()){
            Entry<String,String> entry =iterator2.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());

迭代器Iterator

//方案四：迭代器遍历
        System.out.println("============");
        Set<String> keySet = map.keySet();
        Iterator <String> iterator =keySet.iterator();
         while(iterator.hasNext()){
        String key =iterator.next();
        System.out.println(key);
        System.out.println(map.get(key));

泛型集合：

package JavaOPPDay04fanxing;

public class Dog {

    public String name;
    public String Strain;
    public Dog(String name,String strain){
    this.name=name;
    this.Strain=strain;
    }
    
    
}

package JavaOPPDay04fanxing;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test1 {

    public static void main(String[] args) {
        //创建狗狗对象
        Dog ououdog =new Dog("欧欧","雪纳瑞");
        Dog yayadog =new Dog("丫丫","拉布拉多");
        Dog meimeidog =new Dog("美美","拉布拉多");
        Dog feifei =new Dog("菲菲","拉布拉多");
        //创建Map集合对象放在其中
        Map dogMap =new HashMap();
        dogMap.put(ououdog.name,ououdog);
        dogMap.put(ououdog.name,yayadog);
        dogMap.put(meimeidog.name,meimeidog);
        dogMap.put(feifei.name,feifei);
        //通过迭代器依次输入集合中的所有的狗狗信息
        System.out.println("使用Iterator遍历,"+"所有狗狗的昵称和品种为:");
        Set keys =dogMap.keySet();//取出所有key的集合
        Iterator it =keys.iterator();//获取iterator对象
        while(it.hasNext()){
            String key=(String) it.next();//取出key
            Dog dog =(Dog)dogMap.get(key);//根据key取出对应的值
            System.out.println(key+"	"+dog.Strain);
            
        }
        
        
        

    }

}

泛型集合的应用：

ArrayList和List

package JavaOPPDay0ArrayListandList;


import java.util.ArrayList;
import java.util.List;

import JavaOPPDay04Hash.Dog;

public class Test {

    public static void main(String[] args) {
        //创建狗狗对象
        Dog ououdog =new Dog("欧欧","雪纳瑞");
        Dog yayadog =new Dog("丫丫","拉布拉多");
        Dog meimeidog =new Dog("美美","拉布拉多");
        Dog feifei =new Dog("菲菲","拉布拉多");
        //创建ArrayList集合对象并把多个狗狗对象放入其中
        List<Dog> dogs =new ArrayList<Dog>();//标记元素类型
        dogs.add(ououdog);        
        dogs.add(yayadog);
        dogs.add(meimeidog);
        dogs.add(feifei);
        //dogs.add("Hello");//编译错误，元素类型不是Dog
        //显示第三个狗狗的信息
        Dog dogs1 =dogs.get(1);
        System.out.println("第三个狗的信息如下");
        System.out.println(dogs.get(2).name+"	"+dogs.get(2).Strain);
        //使用foreach遍历
        System.out.println("
所有狗狗的信息如下");
        for(Dog dog:dogs){
            
            System.out.println(dog.name+"	"+dog.Strain);
            
        }
        

    }

}

package JavaOPPDay0ArrayListandList;

public class Dog {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    private String strain;

}

Map和HashMap

public class Test {

    public static void main(String[] args) {
        //创建狗狗对象
                Dog ououdog =new Dog("欧欧","雪纳瑞");
                Dog yayadog =new Dog("丫丫","拉布拉多");
                Dog meimeidog =new Dog("美美","拉布拉多");
                Dog feifei =new Dog("菲菲","拉布拉多");
                //创建Map集合对象并把多个狗狗对象放入其中
                Map<String,Dog> dogMap =new HashMap<String,Dog>();
                dogMap.put(ououdog.name, ououdog);        
                dogMap.put(yayadog.name, yayadog);    
                dogMap.put(meimeidog.name, meimeidog);    
                dogMap.put(feifei.name, feifei);    
                //通过迭代器一次输出集合中的所有信息
                System.out.println("使用Inerator遍历，所有狗狗的昵称和品种是：");
                Set<String> keys =dogMap.keySet();//取出所有key的集合
                Iterator <String> it =keys.iterator();//获取Inerator对象
                while(it.hasNext()){
                    String key =it.next();//取出key值。无须类型转换、
                    Dog dog =dogMap.get(key);//根据key取出对应的值，无须类型转换、
                    System.out.println(key+"	"+dog.Strain);
                
                }
                //for循环遍历
                for(String key:keys){
                    Dog dog1 =dogMap.get(key);
                    System.out.println(key+"	"+dog1.Strain);
                    
                }
    }

}