数组有弊端

    数组需要定义长度，在不知道数据量的前提下使用时比较麻烦的，要频繁的对数组进行扩容

    当向数组中插入元素时，其他元素都要向后移动，这也为我们使用数组提供了额外的维护数组的代码量

所以就有另一种 java中的集合框架

Collection接口

    这个接口定义了集合的相关特征.

     这个接口派生了两个子接口

        List：可重复集合（同一个元素可以放入若干次）

                用一个元素是指的equals 为true的

            有序集

        Set: 不可重复集合

            无序集

方法：

int size() 返回集合中的元素数量里面有多少元素就返回多少

boolean isEmpty() 集合是不是空的没有元素返回true 有元素返回false

boolean contains(Object obj) 集是否包含指定的元素 

void clear() 清空集合

boolean add(E e) 向集合中添加元素

boolean remove(E e) 从集合中删除指定元素

boolean addAll(Collection c):将给定集合中的所有元素添加到当前集合（并集）

boolean removeAll(Collection c):删除当前集合（只删除当前的）中与给定集合相同的元素

Iteator iterator() 迭代器 定义了遍历集合的相关方法，不同的集合有不同的迭代器实现

boolean hasNext() 是否还有元素可以获取

Object next() 获取元素

void remove()删除当前迭代出的元素

遍历集合的顺序要：问->取（->删），删除可不做

List 集合的实现类

    

    ArrayList 内部使用数组实现的集合 比较常用   查询速度快

    根据数组的实现原理，这个集合更适合查询数据，但是对频繁的增删元素 效率低下

    

    LinkedList 使用链表方式实现的机会        频繁的修改元素

    根据链表的实现原理这个集合更适合增删元素，但是对于频繁的查询元素 效率低下

package day27;import java.util.ArrayList;import java.util.List;/** *ArrayList *List 的子类实现  *由数组方式实现的可重复的有序集 */public class Demo01 {	public static void main(String[] args){		List list = new ArrayList();		list.add("1");//list 是有序的集合 所以add方法是顺序向集合末尾添加元素		list.add("2");		list.add("3");		list.add("4");		list.add("5");		list.add("6");		list.add("7");		list.add("8");				System.out.println(list.size());		System.out.println(list.isEmpty());		System.out.println(list);		list.clear();		System.out.println(list.size());		System.out.println(list.isEmpty());		System.out.println(list);					}}

package day27;import java.util.ArrayList;import java.util.List;public class Demo02 {	public static void main(String[] args){		List list1 = new ArrayList();		List list2 = new ArrayList();		List list3 = new ArrayList();						list1.add("1");		list1.add("2");		list1.add("3");				list2.add("4");		list2.add("5");				list3.add("1");		list3.add("2");		//判断元素是否相同，使用的是equals方法		list1.addAll(list2);//将集合2中元素存入集合1		System.out.println(list1);		list1.removeAll(list3);//将集合1中与集合3相同的元素删除		System.out.println(list1);		list1.retainAll(list2);//只保留集合1中与集合2都有的元素 取交集		System.out.println(list1);					}}

增删改查

List接口中定义的方法

get(int index) 获取指定位置的元素  只有List集合具有

set(int index,Object obj)将指定位置上的元素替换为给定元素，返回被替换的元素

add(int index,Object o)重载的方法 在指定位置插入给定的元素，原来的元素顺序向后移动

remove(int index)重载的方法，删除指定位置的元素，返回被删除的元素

indexOf()查找给定元素在集合中第一次出现的位置

lastIndexOf()查找给定元素在集合中最后一次出现的位置

package day27;import java.util.ArrayList;import java.util.List;public class Demo03 {	public static void main(String[] args){		List list = new ArrayList();		list.add("1");		list.add("1");				list.add("2");		list.add("3");//增		list.add("44");		list.remove(2);//删下标是2的		list.add("3");		list.add(1,11);//插入一个新元素		list.remove("44");//删除一个指定的元素		System.out.println("第一次输出集合："+list);		//获取回来时时以Object获取的，需要造型		String element = (String)list.get(2);//有下标越界问题从0开始		System.out.println("输出下标为2的元素："+element);		Object old  =list.set(1,"22");//改		System.out.println("输出将第二个元素修改后的结果:"+list);		System.out.println("输出修改时候的返回值:"+old);		int index = list.indexOf("3");//第一次出现的位置		System.out.println("元素第一次出现的位置"+index);		int lastindex = list.lastIndexOf("1");		System.out.println("元素最后一次出现的位置"+lastindex);		for(int i = 0 ; i

Collection定义的方法：

toArray()

package day27;import java.util.ArrayList;import java.util.Arrays;import java.util.List;public class Demo04 {	public static void main(String[] args){		List list = new ArrayList();		list.add("1");		list.add("2");		list.add("3");		Object[] array = list.toArray();				//参数给定的就是具体要转换的数组的实例，不需要长度 减少浪费空间		//返回时要造型		//要转换的数组类型要和集合中存放的类型一致												//  **********		//所有数组都是Array的类型		String[] strArray = (String[])list.toArray(new String[0]);		System.out.println(Arrays.toString(strArray));				List list2 = new ArrayList();		list2.add(1);		list2.add(2);		list2.add(3);		Integer[] intArray = (Integer[])list2.toArray(new Integer[0]);		System.out.println(Arrays.toString(intArray));			}}

package day27;import java.util.Iterator;import java.util.LinkedList;import java.util.List;public class Demo05 {	public static void main(String[] args){		List list = new LinkedList();		list.add("1");		list.add("#");		list.add("2");		list.add("#");		list.add("3");		list.add("#");		list.add("4");		list.add("#");		list.add("5");				Iterator it = list.iterator();		while(it.hasNext()){			String element = (String)it.next();			if("#".equals(element)){				it.remove();//通过迭代器删除刚刚被迭代出来的元素			}			System.out.println(element);		}		System.out.println(list);	}}

泛型

    1.5 之后的特性

    泛型的本质就是参数化类型，在使用某个类时为方法，属性等指定类型。

    允许多个 泛型 使用 , 隔开   

    更加灵活

    动态给类型

    尽量使用有意义的名字

    泛型不能参与运算

    定义后不指定类型，就是Object类

    java 是强类型语言 不像python 

    so 泛型是假的 其实他还是Object 只是java知道他是你指定的类型 会自动的类型转换， 也有可能会有类造型异常的现象(ClassCastException)（自己作孽）

package day27;public class Demo07
     
       {	private X x;	private Y y;		public Demo07(X x,Y y){		this.x = x;		this.y = y;	}		public X getX(){		return x;	}		public Y getY(){		return y;	}	public void setX(X x){		this.x = x;	}	public void setY(Y y){		this.y = y;	}}
     

package day27;public class Demo08 {	public static void main(String[] args){		Demo07
     
       p = new Demo07
      
       (3.14,"3.14");		Demo07
       
         p2 = new Demo07
        
         (1,1);		Demo07
         
           p3 = new Demo07
          
           (1,"1"); Demo07 p4 = new Demo07(1,2);//定义后不指定类型，就是Object类 p.setX(3.1415); p2.setX(111); p3.setY("3.123"); }}
          
         
        
       
      
     

package day27;//泛型是假的 其实他还是Object 只是java知道他是你指定的类型 会自动的类型转换， 也有可能会有类造型异常的现象(ClassCastException)（自己作孽）public class Demo09 {	public static void main(String[] ags){		Demo07
     
       p = new Demo07
      
       (1,1);		p.setX(2);		p.setY(2);		set(p);		int x = p.getX();//Exception in thread "main" java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.Integer		int y = p.getY();		System.out.println(x+","+y);	}		public static void set(Demo07 p){		p.setX(3.1);		p.setY(3.1);	}	}
      
     

集合中的泛型

    集合中的泛型通常是约束集合中存放元素的类型

package day27;import java.util.ArrayList;import java.util.List;public class Demo10 {	public static void main(String[] args){		List
     
       list = new ArrayList
      
       ();//限制了list 集合中的数据，只能是String类型		list.add("1");//泛型约束了add 方法的参数类型		//list.add(1); 		String element  = list.get(0);//也约束了get方法的返回值类型		System.out.println(element);	}}
      
     

    迭代器也支持泛型，知识需要注意 迭代器的泛型应该与要迭代的集合的泛型保持一致

package day27;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Demo11 {	public static void main(String[] args){		List
     
       list = new ArrayList
      
       ();//限制了list 集合中的数据，只能是String类型		list.add("一");//泛型约束了add 方法的参数类型		//list.add(1); 		list.add("二");		list.add("三");		list.add("四");		String element  = list.get(0);//也约束了get方法的返回值类型		System.out.println(element);		System.out.println("--------------------");		Iterator
       
         it = list.iterator();		while(it.hasNext()){			String elements = it.next();			System.out.println(elements);		}	}}