Java中的集合

java中的集合框架是指一系列存储数据的接口和类,若集合中没有指定泛型，则集合会自动装箱，将添加进去的数据转为object类型

                                            Collection 接口

                 List接口                                                     Set接口

Vector类,ArrayList类,LinkendList类               HashSet类,TreeSet类

               

                                             Map接口

 HashMap类                                                               HashTable类

Collection接口的子接口有:List接口,Set接口

List接口:Vector类,ArrayList类,LinkedList类

List接口特点:1.存储顺序有序，2.可以保存重复元素

Vector类和ArrayList类的用法是一样的，但是 ArrayList的效率高，线程不安全. Vector的效率低，线程安全

   
   

    
    

     
     List list = new ArrayList();
    
    
    
    

     
     		Student stu = new Student("呵呵", 20, '男');
    
    
    
    

     
     		String[] arrInt = {"abc","def","ghe"};
    
    
    
    

     
     		
    
    
    
    

     
     		list.add(100);//添加数据
    
    
    
    

     
     		list.add(1,"hehehehe");//根据下标添加数据,后面的数据往后移动
    
    
    
    

     
     		list.add(stu);
    
    
    
    

     
     		list.add(arrInt);
    
    
    
    

     
     		
    
    
    
    

     
     		System.out.println(list.size());//获得集合的大小
    
    
    
    

     
     		System.out.println(list.get(2)+" "+list.get(3));//根据下标得到元素的内容
    
    
    
    

     
     		
    
    
    
    

     
     		list.set(0, 20);//将0位置的元素改为20
    
    
    
    

     
     		System.out.println(list.get(0));
    
    
    
    

     
     		
    
    
    
    

     
     		list.remove(3);//删除这个元素
    
    
    
    

     
     		System.out.println(list.size());
    
    
    
    

     
     		
    
    
    
    

     
     		System.out.println(list.contains("hehehehe"));
    
    
    
    

     
     		
    
    
    
    

     
     		//list.clear();//全部清空
    
    
   
   

ArrayList类和LinkedList类

LinkedList存放元素是按照先进先出方式排序的

LinkedList:主要用于经常添加或者删除元素的集合，效率较高。

ArrayList:主要用于遍历集合，效率较高。

   
   

    
    

     
     LinkedList list = new LinkedList();
    
    
    
    

     
     		list.add(0);
    
    
    
    

     
     		list.add(1);
    
    
    
    

     
     		list.addFirst(10);//添加到第一个
    
    
    
    

     
     		list.addLast(20);//添加到最后一个
    
    
    
    

     
     		
    
    
    
    

     
     		list.removeLast();
    
    
    
    

     
     		list.removeFirst();
    
    
    
    

     
     		
    
    
    
    

     
     		System.out.println(list.size());
    
    
   
   

Set接口

Set接口:HashSet和TreeSet一个线程安全，一个线程不安全

Set接口特点:无序，不能重复

用法和List相似

   
   

    
    

     
     /**
    
    
    
    

     
     	 * set接口特点：1.无序的  2.不能重复
    
    
    
    

     
     	 */
    
    
    
    

     
     	public static void main(String[] args) {
    
    
    
    

     
     		Set set = new HashSet();
    
    
    
    

     
     		set.add("元素01");
    
    
    
    

     
     		set.add("元素02");
    
    
    
    

     
     		set.add("元素01");
    
    
    
    

     
     		set.add("元素03");
    
    
    
    

     
     		System.out.println(set.size());
    
    
    
    

     
     		//第一种方法:访问set中的元素用迭代器
    
    
    
    

     
     //		Iterator iterator = set.iterator();
    
    
    
    

     
     //		while (iterator.hasNext()) {//判断有没有下一个元素
    
    
    
    

     
     //			System.out.println(iterator.next());//获取下一个元素
    
    
    
    

     
     //		}
    
    
    
    

     
     		
    
    
    
    

     
     		//第二种方法: 用增强for循环
    
    
    
    

     
     		for (Object object : set) {
    
    
    
    

     
     			System.out.println(object);
    
    
    
    

     
     		}
    
    
    
    

     
     	}
    
    
   
   

 Map接口

 Map接口:  HashMap类 , HashTable类  

 Map接口 特点:①以键值对形式保存数据②键值不能重复，value值可以重复，key值重复会覆盖③元素的保存是无序的

区别：一个线程安全，一个不安全， HashMap中的key可以为null HashTable不能为null

   
   

    
    

     
     /**
    
    
    
    

     
     	 *HashMap中的key可以为null HashTable不能为
    
    
    
    

     
     	 */
    
    
    
    

     
     	public static void main(String[] args) {
    
    
    
    

     
     		Map map = new HashMap();
    
    
    
    

     
     		//添加元素
    
    
    
    

     
     		map.put(1, "哈哈");
    
    
    
    

     
     		map.put("str2", "呵呵呵");
    
    
    
    

     
     		map.put("str2", "啊大大");//key值相同时，value会覆盖
    
    
    
    

     
     		map.put(2, "sad");
    
    
    
    

     
     		map.put(null, "为asd");
    
    
    
    

     
     		System.out.println(map.isEmpty());//判断map集合是否为空
    
    
    
    

     
     		System.out.println(map.get(2));
    
    
    
    

     
     		System.out.println(map.containsKey(2));//判断key值是否存在 
    
    
    
    

     
     		System.out.println(map.containsValue("sad"));//判断key值是否存在 
    
    
    
    

     
     		
    
    
    
    

     
     		//遍历map中所有的key值
    
    
    
    

     
     		for (Object obj : map.keySet()) {
    
    
    
    

     
     			System.out.println(obj);
    
    
    
    

     
     		}
    
    
    
    

     
     		
    
    
    
    

     
     		//遍历map中所有的value值
    
    
    
    

     
     		for (Object obj : map.values()) {
    
    
    
    

     
     			System.out.println(obj);
    
    
    
    

     
     		}
    
    
    
    

     
     		
    
    
    
    

     
     		map.clear();//清除所有的元素
    
    
    
    

     
     	}
    
    
   
   

 泛型 

   
   

    
    

     
     /**
    
    
    
    

     
     	 * 泛型，强制规定为什么类型
    
    
    
    

     
     	 */
    
    
    
    

     
     	public static void main(String[] args) {
    
    
    
    

     
     		System.out.println("==============list泛型=============");
    
    
    
    

     
     		
    
    
    
    

     
     		List<Dog> list = new ArrayList
    
    
    
    

     
     				<Dog>();
    
    
    
    

     
     		Dog dog1 = new Dog();
    
    
    
    

     
     		Dog dog2 = new Dog();
    
    
    
    

     
     		Dog dog3 = new Dog();
    
    
    
    

     
     		list.add(dog1);
    
    
    
    

     
     		list.add(dog2);
    
    
    
    

     
     		list.add(dog3);
    
    
    
    

     
     		for (Dog dog : list) {
    
    
    
    

     
     			dog.speakInfo();
    
    
    
    

     
     		}
    
    
    
    

     
     		
    
    
    
    

     
     		System.out.println("==============set泛型=============");
    
    
    
    

     
     		
    
    
    
    

     
     		Set<Dog> set = new HashSet<Dog>();
    
    
    
    

     
     		Dog dog4 = new Dog();
    
    
    
    

     
     		Dog dog5 = new Dog();
    
    
    
    

     
     		Dog dog6 = new Dog();
    
    
    
    

     
     		set.add(dog4);
    
    
    
    

     
     		set.add(dog5);
    
    
    
    

     
     		set.add(dog6);
    
    
    
    

     
     		for (Dog dog : set) {
    
    
    
    

     
     			dog.speakInfo();
    
    
    
    

     
     		}
    
    
    
    

     
     		
    
    
    
    

     
     		System.out.println("==============map泛型=============");
    
    
    
    

     
     		
    
    
    
    

     
     		Map<String, Dog> map = new HashMap<String, Dog>();//key值为String类型,value值为Dog类型
    
    
    
    

     
     		map.put("1", dog1);
    
    
    
    

     
     		map.put("2", dog2);
    
    
    
    

     
     		map.put("3", dog3);
    
    
    
    

     
     		for (Dog dog : map.values()) {
    
    
    
    

     
     			dog.speakInfo();
    
    
    
    

     
     		}
    
    
    
    

     
     		for (String str : map.keySet()) {
    
    
    
    

     
     			System.out.println(str);
    
    
    
    

     
     		}
    
    
    
    

     
     	}
    
    
   
   

 泛型类

    
    

     
     

      
      //泛型类
     
     
     
     

      
      public class FXClass<E> {
     
     
     
     

      
       
     
     
     
     

      
      	private String name;
     
     
     
     

      
      	private E obj;
     
     
     
     

      
      	public String getName() {
     
     
     
     

      
      		return name;
     
     
     
     

      
      	}
     
     
     
     

      
      	public void setName(String name) {
     
     
     
     

      
      		this.name = name;
     
     
     
     

      
      	}
     
     
     
     

      
      	public E getObj() {
     
     
     
     

      
      		return obj;
     
     
     
     

      
      	}
     
     
     
     

      
      	public void setObj(E obj) {
     
     
     
     

      
      		this.obj = obj;
     
     
     
     

      
      	}
     
     
     
     

      
      	
     
     
     
     

      
      	
     
     
     
     

      
       
     
     
     
     

      
      }
     
     
    
    

     
     

      
      

       
       //泛型类的测试类
      
      
      
      

       
       public class FXClassTest {
      
      
      
      

       
        
      
      
      
      

       
       	/**
      
      
      
      

       
       	 * @param args
      
      
      
      

       
       	 */
      
      
      
      

       
       	public static void main(String[] args) {
      
      
      
      

       
       	 	FXClass<Dog> fc = new FXClass<Dog>();//创建泛型类对象
      
      
      
      

       
       	 	Dog dog = new Dog();//创建Dog类对象
      
      
      
      

       
       	 	dog.setPetName("小新");//给dog赋值
      
      
      
      

       
       	 	fc.setObj(dog);//将dog类对象放入到泛型对象里面
      
      
      
      

       
       	 	fc.getObj().speakInfo();//通过泛型类对象得到dog对象类型中的方法
      
      
      
      

       
       	 	
      
      
      
      

       
       	}
      
      
      
      

       
        
      
      
      
      

       
       }